idx
int64 0
7.85k
| idx_lca
int64 0
223
| offset
int64 162
55k
| repo
stringclasses 62
values | commit_hash
stringclasses 113
values | target_file
stringclasses 134
values | line_type_lca
stringclasses 7
values | ground_truth
stringlengths 1
46
| in_completions
bool 1
class | completion_type
stringclasses 6
values | non_dunder_count_intellij
int64 0
529
| non_dunder_count_jedi
int64 0
128
| start_with_
bool 2
classes | first_occurrence
bool 2
classes | intellij_completions
listlengths 1
532
| jedi_completions
listlengths 3
148
| prefix
stringlengths 162
55k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1,577 | 39 | 14,786 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
s
| true |
statement
| 12 | 20 | false | false |
[
"s",
"host",
"m",
"renew_action_lease",
"delete_state",
"__getattr__",
"__init__",
"assert_fact",
"cancel_timer",
"get_facts",
"get_pending_events",
"post",
"retract_fact",
"start_timer",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "host",
"type": "statement"
},
{
"name": "m",
"type": "statement"
},
{
"name": "post",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "s",
"type": "statement"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "_completed",
"type": "statement"
},
{
"name": "_deleted",
"type": "statement"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_has_completed",
"type": "function"
},
{
"name": "_is_deleted",
"type": "function"
},
{
"name": "_m",
"type": "statement"
},
{
"name": "_ruleset",
"type": "statement"
},
{
"name": "_start_time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.
|
1,579 | 39 | 14,858 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"_handle_result",
"_actions",
"_host",
"_name",
"__init__",
"_definition",
"_flush_actions",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self.
|
1,580 | 39 | 14,961 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
update_state
| true |
function
| 32 | 35 | false | false |
[
"start_action",
"abandon_action",
"get_facts",
"create_ruleset",
"complete_and_start_action",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.
|
1,581 | 39 | 14,979 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"delete_state",
"get_state",
"_host",
"_actions",
"__init__",
"_definition",
"_flush_actions",
"_handle_result",
"_name",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self.
|
1,582 | 39 | 15,101 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
complete_and_start_action
| true |
function
| 32 | 35 | false | true |
[
"update_state",
"start_action",
"abandon_action",
"get_facts",
"create_ruleset",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.
|
1,583 | 39 | 15,132 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"_actions",
"_handle_result",
"_flush_actions",
"do_actions",
"__init__",
"_definition",
"_host",
"_name",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self.
|
1,585 | 39 | 15,201 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"_handle_result",
"_actions",
"_host",
"_name",
"__init__",
"_definition",
"_flush_actions",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self.
|
1,587 | 39 | 15,749 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
abandon_action
| true |
function
| 32 | 35 | false | false |
[
"abandon_action",
"renew_action_lease",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.
|
1,588 | 39 | 15,769 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_actions",
"_handle",
"_flush_actions",
"do_actions",
"_host",
"__init__",
"_definition",
"_handle_result",
"_name",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self.
|
1,590 | 39 | 16,079 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
abandon_action
| true |
function
| 32 | 35 | false | false |
[
"abandon_action",
"renew_action_lease",
"delete_state",
"start_timer",
"cancel_timer",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_ruleset",
"delete_ruleset",
"DurableRulesEngine",
"error",
"get_events",
"get_facts",
"get_state",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"update_state",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.
|
1,591 | 39 | 16,099 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_actions",
"_handle",
"_flush_actions",
"do_actions",
"_host",
"__init__",
"_definition",
"_handle_result",
"_name",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self.
|
1,594 | 39 | 16,278 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
delete_state
| true |
function
| 34 | 34 | false | false |
[
"_actions",
"_handle",
"_name",
"_host",
"_flush_actions",
"__init__",
"_definition",
"_handle_result",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.
|
1,595 | 39 | 16,293 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
s
| true |
statement
| 12 | 20 | false | false |
[
"s",
"m",
"delete_state",
"host",
"retract_fact",
"__getattr__",
"__init__",
"assert_fact",
"cancel_timer",
"get_facts",
"get_pending_events",
"post",
"renew_action_lease",
"start_timer",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "host",
"type": "statement"
},
{
"name": "m",
"type": "statement"
},
{
"name": "post",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "s",
"type": "statement"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "_completed",
"type": "statement"
},
{
"name": "_deleted",
"type": "statement"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_has_completed",
"type": "function"
},
{
"name": "_is_deleted",
"type": "function"
},
{
"name": "_m",
"type": "statement"
},
{
"name": "_ruleset",
"type": "statement"
},
{
"name": "_start_time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.
|
1,596 | 39 | 16,427 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_actions
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"_actions",
"_name",
"_definition",
"_host",
"__init__",
"_flush_actions",
"_handle_result",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self.
|
1,597 | 39 | 16,579 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
start_action_for_state
| true |
function
| 32 | 35 | false | true |
[
"start_action",
"update_state",
"abandon_action",
"get_facts",
"create_ruleset",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.
|
1,598 | 39 | 16,607 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"_actions",
"_handle_result",
"delete_state",
"update_state",
"__init__",
"_definition",
"_flush_actions",
"_host",
"_name",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self.
|
1,599 | 39 | 16,733 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_flush_actions
| true |
function
| 34 | 34 | true | true |
[
"_actions",
"_handle",
"_name",
"_host",
"delete_state",
"__init__",
"_definition",
"_flush_actions",
"_handle_result",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self.
|
1,600 | 39 | 17,022 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
start_action
| true |
function
| 32 | 35 | false | true |
[
"get_facts",
"create_ruleset",
"update_state",
"assert_fact",
"retract_fact",
"abandon_action",
"assert_event",
"assert_events",
"assert_facts",
"assert_timers",
"cancel_timer",
"complete_and_start_action",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_ruleset",
"delete_state",
"DurableRulesEngine",
"error",
"get_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_action",
"start_action_for_state",
"start_timer",
"_logger",
"__instance"
] |
[
{
"name": "abandon_action",
"type": "function"
},
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "assert_timers",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_and_start_action",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_ruleset",
"type": "function"
},
{
"name": "delete_ruleset",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "DurableRulesEngine",
"type": "class"
},
{
"name": "error",
"type": "class"
},
{
"name": "get_events",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "json",
"type": "module"
},
{
"name": "logging",
"type": "module"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "requests",
"type": "module"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_action",
"type": "function"
},
{
"name": "start_action_for_state",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_logger",
"type": "statement"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__instance",
"type": "statement"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.
|
1,601 | 39 | 17,040 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_handle
| true |
statement
| 34 | 34 | true | false |
[
"_handle",
"_actions",
"_handle_result",
"_host",
"_name",
"__init__",
"_definition",
"_flush_actions",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self.
|
1,602 | 39 | 17,085 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
_flush_actions
| true |
function
| 34 | 34 | true | false |
[
"_handle",
"_name",
"_actions",
"_host",
"retract_fact",
"__init__",
"_definition",
"_flush_actions",
"_handle_result",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self.
|
1,605 | 39 | 17,361 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
_transform
| true |
function
| 31 | 35 | true | true |
[
"_name",
"_host",
"_definition",
"_transform",
"retract_fact",
"__init__",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "_transform",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self.
|
1,606 | 39 | 17,460 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
__init__
| true |
function
| 34 | 34 | true | false |
[
"_host",
"_name",
"_handle",
"_definition",
"__init__",
"_actions",
"_flush_actions",
"_handle_result",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).
|
1,608 | 39 | 17,558 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_definition
| true |
statement
| 31 | 35 | true | false |
[
"_definition",
"_host",
"_name",
"retract_fact",
"assert_fact",
"__init__",
"_transform",
"assert_event",
"assert_events",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "_transform",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self.
|
1,611 | 39 | 22,460 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_transform
| true |
function
| 31 | 35 | true | false |
[
"_name",
"_host",
"_definition",
"_transform",
"retract_fact",
"__init__",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "_transform",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self.
|
1,612 | 39 | 22,540 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
__init__
| true |
function
| 34 | 34 | true | false |
[
"_host",
"_name",
"_handle",
"_definition",
"__init__",
"_actions",
"_flush_actions",
"_handle_result",
"assert_event",
"assert_events",
"assert_fact",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).
|
1,614 | 39 | 22,638 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_definition
| true |
statement
| 31 | 35 | true | false |
[
"_definition",
"_host",
"_name",
"retract_fact",
"assert_fact",
"__init__",
"_transform",
"assert_event",
"assert_events",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"create_rulesets",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_facts",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_actions",
"type": "statement"
},
{
"name": "_definition",
"type": "statement"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle",
"type": "statement"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "_host",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "_transform",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self.
|
1,624 | 39 | 28,461 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
register_rulesets
| true |
function
| 37 | 37 | false | true |
[
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"delete_message_callback",
"get_idle_state_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.
|
1,625 | 39 | 28,514 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
_run
| true |
function
| 37 | 37 | true | true |
[
"store_message_callback",
"queue_message_callback",
"get_idle_state_callback",
"delete_message_callback",
"get_queued_messages_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self.
|
1,626 | 39 | 28,914 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_directory
| true |
statement
| 37 | 37 | true | true |
[
"_ruleset_list",
"_ruleset_directory",
"save_ruleset",
"load_ruleset",
"register_rulesets",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self.
|
1,627 | 39 | 28,958 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_directory
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_directory",
"_ruleset_list",
"_handle_function",
"load_ruleset",
"save_ruleset",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self.
|
1,628 | 39 | 29,043 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
load_ruleset
| true |
function
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"save_ruleset",
"register_rulesets",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.
|
1,629 | 39 | 29,087 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
register_rulesets
| true |
function
| 37 | 37 | false | false |
[
"_ruleset_list",
"_ruleset_directory",
"load_ruleset",
"_d_timer",
"_t_timer",
"__init__",
"_handle_function",
"_run",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.
|
1,630 | 39 | 29,149 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_directory
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_directory",
"_ruleset_list",
"load_ruleset",
"_handle_function",
"register_rulesets",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self.
|
1,631 | 39 | 29,245 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
register_rulesets
| true |
function
| 37 | 37 | false | false |
[
"_ruleset_directory",
"get_ruleset",
"_ruleset_list",
"save_ruleset",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.
|
1,632 | 39 | 29,378 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
save_ruleset
| true |
function
| 37 | 37 | false | true |
[
"_ruleset_directory",
"get_ruleset",
"_ruleset_list",
"register_rulesets",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.
|
1,633 | 39 | 30,059 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
post_batch
| true |
function
| 37 | 37 | false | true |
[
"get_ruleset",
"_ruleset_directory",
"_handle_function",
"_ruleset_list",
"queue_message_callback",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.
|
1,634 | 39 | 30,115 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | true |
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"queue_message_callback",
"store_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.
|
1,635 | 39 | 30,161 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
_handle_function
| true |
function
| 37 | 37 | true | true |
[
"get_ruleset",
"post_batch",
"_ruleset_directory",
"_ruleset_list",
"_handle_function",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self.
|
1,636 | 39 | 30,311 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"queue_message_callback",
"store_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.
|
1,637 | 39 | 30,357 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle_function
| true |
function
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_directory",
"_handle_function",
"_ruleset_list",
"queue_message_callback",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self.
|
1,638 | 39 | 30,544 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
assert_facts
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_directory",
"retract_fact",
"_handle_function",
"_ruleset_list",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.
|
1,639 | 39 | 30,599 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_list",
"retract_fact",
"load_ruleset",
"assert_facts",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.
|
1,640 | 39 | 30,645 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle_function
| true |
function
| 37 | 37 | true | false |
[
"get_ruleset",
"assert_facts",
"_ruleset_directory",
"retract_fact",
"_ruleset_list",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self.
|
1,641 | 39 | 30,790 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_list",
"assert_fact",
"retract_fact",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.
|
1,642 | 39 | 30,836 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle_function
| true |
function
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_directory",
"retract_fact",
"assert_fact",
"_handle_function",
"__init__",
"_d_timer",
"_ruleset_list",
"_run",
"_t_timer",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self.
|
1,643 | 39 | 30,982 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"assert_fact",
"assert_facts",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.
|
1,644 | 39 | 31,028 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
_handle_function
| true |
function
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_directory",
"assert_facts",
"assert_fact",
"_handle_function",
"__init__",
"_d_timer",
"_ruleset_list",
"_run",
"_t_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self.
|
1,645 | 39 | 31,175 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_list",
"retract_fact",
"load_ruleset",
"assert_fact",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.
|
1,646 | 39 | 31,221 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_handle_function
| true |
function
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_directory",
"retract_fact",
"assert_facts",
"assert_fact",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_list",
"_run",
"_t_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self.
|
1,647 | 39 | 31,369 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"get_idle_state_callback",
"delete_state",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.
|
1,648 | 39 | 31,408 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_handle_function
| true |
function
| 37 | 37 | true | false |
[
"get_idle_state_callback",
"register_rulesets",
"get_ruleset",
"_d_timer",
"_t_timer",
"__init__",
"_handle_function",
"_ruleset_directory",
"_ruleset_list",
"_run",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self.
|
1,649 | 39 | 31,539 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_directory",
"_handle_function",
"get_idle_state_callback",
"_ruleset_list",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.
|
1,650 | 39 | 31,646 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_directory",
"delete_message_callback",
"get_idle_state_callback",
"_ruleset_list",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.
|
1,651 | 39 | 31,762 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_directory",
"_ruleset_list",
"register_rulesets",
"get_action",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.
|
1,652 | 39 | 31,882 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_directory",
"retract_fact",
"assert_facts",
"_handle_function",
"__init__",
"_d_timer",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.
|
1,653 | 39 | 32,002 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_ruleset",
"_ruleset_directory",
"_handle_function",
"_ruleset_list",
"get_idle_state_callback",
"__init__",
"_d_timer",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.
|
1,655 | 39 | 32,173 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_ruleset_list
| true |
statement
| 37 | 37 | true | true |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"store_message_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self.
|
1,657 | 39 | 32,364 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"delete_message_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self.
|
1,659 | 39 | 32,554 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"queue_message_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self.
|
1,661 | 39 | 32,755 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"get_queued_messages_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self.
|
1,662 | 39 | 32,923 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_queued_messages_callback",
"get_ruleset",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.
|
1,664 | 39 | 33,123 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"get_idle_state_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self.
|
1,665 | 39 | 33,281 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
get_ruleset
| true |
function
| 37 | 37 | false | false |
[
"get_idle_state_callback",
"get_ruleset",
"_ruleset_directory",
"register_rulesets",
"delete_state",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_list",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.
|
1,666 | 39 | 33,435 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
create_rulesets
| true |
function
| 28 | 30 | false | true |
[
"create_rulesets",
"retract_fact",
"assert_fact",
"assert_event",
"get_facts",
"__init__",
"assert_events",
"assert_facts",
"cancel_timer",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"dispatch",
"dispatch_timers",
"do_actions",
"get_definition",
"get_pending_events",
"get_state",
"renew_action_lease",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_get_stored_messages_callback",
"set_queue_message_callback",
"set_store_message_callback",
"start_timer",
"update_state",
"mro",
"__annotations__",
"__base__",
"__bases__",
"__basicsize__",
"__call__",
"__delattr__",
"__dict__",
"__dictoffset__",
"__dir__",
"__eq__",
"__flags__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__instancecheck__",
"__itemsize__",
"__mro__",
"__name__",
"__ne__",
"__new__",
"__or__",
"__prepare__",
"__qualname__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__ror__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasscheck__",
"__subclasses__",
"__subclasshook__",
"__text_signature__",
"__weakrefoffset__",
"__class__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_event",
"type": "function"
},
{
"name": "assert_events",
"type": "function"
},
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "cancel_timer",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "create_rulesets",
"type": "function"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "dispatch",
"type": "function"
},
{
"name": "dispatch_timers",
"type": "function"
},
{
"name": "do_actions",
"type": "function"
},
{
"name": "get_definition",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "mro",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_get_stored_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "start_timer",
"type": "function"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_flush_actions",
"type": "function"
},
{
"name": "_handle_result",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__base__",
"type": "statement"
},
{
"name": "__bases__",
"type": "statement"
},
{
"name": "__basicsize__",
"type": "statement"
},
{
"name": "__call__",
"type": "function"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dictoffset__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__flags__",
"type": "statement"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__instancecheck__",
"type": "function"
},
{
"name": "__itemsize__",
"type": "statement"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mro__",
"type": "statement"
},
{
"name": "__name__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__prepare__",
"type": "function"
},
{
"name": "__qualname__",
"type": "statement"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__subclasscheck__",
"type": "function"
},
{
"name": "__subclasses__",
"type": "function"
},
{
"name": "__text_signature__",
"type": "statement"
},
{
"name": "__weakrefoffset__",
"type": "statement"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.
|
1,667 | 39 | 33,569 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_directory
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"load_ruleset",
"save_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self.
|
1,668 | 39 | 33,725 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_ruleset_directory
| true |
statement
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_list",
"_ruleset_directory",
"save_ruleset",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self.
|
1,669 | 39 | 33,789 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"load_ruleset",
"save_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self.
|
1,670 | 39 | 33,844 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
store_message_callback
| true |
statement
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"queue_message_callback",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.
|
1,671 | 39 | 33,928 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
store_message_callback
| true |
statement
| 37 | 37 | false | false |
[
"_ruleset_list",
"queue_message_callback",
"delete_message_callback",
"get_queued_messages_callback",
"_ruleset_directory",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.
|
1,672 | 39 | 33,977 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
delete_message_callback
| true |
statement
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"store_message_callback",
"get_ruleset",
"queue_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.
|
1,673 | 39 | 34,063 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
delete_message_callback
| true |
statement
| 37 | 37 | false | false |
[
"_ruleset_list",
"queue_message_callback",
"store_message_callback",
"get_queued_messages_callback",
"_ruleset_directory",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.
|
1,674 | 39 | 34,113 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
queue_message_callback
| true |
statement
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"store_message_callback",
"get_ruleset",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.
|
1,675 | 39 | 34,197 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
queue_message_callback
| true |
statement
| 37 | 37 | false | false |
[
"_ruleset_list",
"store_message_callback",
"delete_message_callback",
"get_queued_messages_callback",
"_ruleset_directory",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.
|
1,676 | 39 | 34,246 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
get_stored_messages_callback
| true |
statement
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.
|
1,677 | 39 | 34,342 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_stored_messages_callback
| true |
statement
| 37 | 37 | false | false |
[
"_ruleset_list",
"get_ruleset",
"store_message_callback",
"queue_message_callback",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.
|
1,678 | 39 | 34,397 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
get_queued_messages_callback
| true |
statement
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.
|
1,679 | 39 | 34,493 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_queued_messages_callback
| true |
statement
| 37 | 37 | false | false |
[
"_ruleset_list",
"get_ruleset",
"queue_message_callback",
"store_message_callback",
"delete_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_ruleset_directory",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.
|
1,680 | 39 | 34,548 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
inproject
|
get_idle_state_callback
| true |
statement
| 37 | 37 | false | true |
[
"_ruleset_list",
"_ruleset_directory",
"queue_message_callback",
"store_message_callback",
"get_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.
|
1,681 | 39 | 34,634 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
get_idle_state_callback
| true |
statement
| 37 | 37 | false | false |
[
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"get_idle_state_callback",
"load_ruleset",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.
|
1,682 | 39 | 34,784 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
random
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_ruleset_directory",
"get_ruleset",
"queue_message_callback",
"store_message_callback",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self.
|
1,684 | 39 | 34,898 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_d_timer
| true |
statement
| 37 | 37 | true | true |
[
"get_ruleset",
"_ruleset_list",
"_run",
"_ruleset_directory",
"_d_timer",
"__init__",
"_handle_function",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self.
|
1,685 | 39 | 34,942 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_d_timer
| true |
statement
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_list",
"_ruleset_directory",
"_run",
"register_rulesets",
"__init__",
"_d_timer",
"_handle_function",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self.
|
1,686 | 39 | 35,008 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
commited
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"_ruleset_directory",
"register_rulesets",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self.
|
1,687 | 39 | 35,266 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 38 | 37 | true | false |
[
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"_d_timer",
"register_rulesets",
"__init__",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"yield",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self.
|
1,689 | 39 | 35,422 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
infile
|
_ruleset_list
| true |
statement
| 39 | 37 | true | false |
[
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"_t_timer",
"_d_timer",
"__init__",
"_handle_function",
"_run",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"for",
"yield",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self.
|
1,690 | 39 | 35,461 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_d_timer
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"get_ruleset",
"_run",
"_ruleset_directory",
"assert_fact",
"__init__",
"_d_timer",
"_handle_function",
"_t_timer",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self.
|
1,691 | 39 | 35,505 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_d_timer
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"_run",
"register_rulesets",
"__init__",
"_d_timer",
"_handle_function",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self.
|
1,692 | 39 | 35,587 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"_ruleset_list",
"_t_timer",
"_d_timer",
"_ruleset_directory",
"queue_message_callback",
"__init__",
"_handle_function",
"_run",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_ruleset",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self.
|
1,694 | 39 | 35,700 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_t_timer
| true |
statement
| 37 | 37 | true | true |
[
"_t_timer",
"_d_timer",
"_run",
"get_ruleset",
"assert_fact",
"__init__",
"_handle_function",
"_ruleset_directory",
"_ruleset_list",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self.
|
1,695 | 39 | 35,744 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
common
|
_t_timer
| true |
statement
| 37 | 37 | true | false |
[
"_t_timer",
"_d_timer",
"_run",
"get_ruleset",
"_ruleset_list",
"__init__",
"_handle_function",
"_ruleset_directory",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self.
|
1,696 | 39 | 35,810 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 37 | 37 | true | false |
[
"get_ruleset",
"_ruleset_list",
"load_ruleset",
"_ruleset_directory",
"register_rulesets",
"__init__",
"_d_timer",
"_handle_function",
"_run",
"_t_timer",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"post",
"post_batch",
"queue_message_callback",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self.
|
1,697 | 39 | 36,074 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
common
|
_ruleset_list
| true |
statement
| 38 | 37 | true | false |
[
"_t_timer",
"_ruleset_list",
"_d_timer",
"get_ruleset",
"_ruleset_directory",
"__init__",
"_handle_function",
"_run",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"yield",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self.
|
1,699 | 39 | 36,229 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_ruleset_list
| true |
statement
| 39 | 37 | true | false |
[
"_d_timer",
"_t_timer",
"_ruleset_list",
"get_ruleset",
"_ruleset_directory",
"__init__",
"_handle_function",
"_run",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"for",
"yield",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self.
|
1,700 | 39 | 36,268 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_t_timer
| true |
statement
| 37 | 37 | true | false |
[
"_t_timer",
"_d_timer",
"_ruleset_list",
"_run",
"get_ruleset",
"__init__",
"_handle_function",
"_ruleset_directory",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self._ruleset_list),))
self.
|
1,701 | 39 | 36,312 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_t_timer
| true |
statement
| 37 | 37 | true | false |
[
"_t_timer",
"_d_timer",
"_ruleset_list",
"_run",
"get_ruleset",
"__init__",
"_handle_function",
"_ruleset_directory",
"assert_fact",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self._ruleset_list),))
self._t_timer.daemon = True
self.
|
1,703 | 39 | 36,412 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_d_timer
| true |
statement
| 37 | 37 | true | false |
[
"_d_timer",
"_t_timer",
"_ruleset_list",
"get_ruleset",
"assert_fact",
"__init__",
"_handle_function",
"_ruleset_directory",
"_run",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self._ruleset_list),))
self._t_timer.daemon = True
self._t_timer.start()
self._d_timer = threading.Timer(0.1, dispatch_ruleset, (0,))
self.
|
1,704 | 39 | 36,448 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
common
|
_d_timer
| true |
statement
| 37 | 37 | true | false |
[
"_d_timer",
"_t_timer",
"_ruleset_list",
"get_ruleset",
"assert_fact",
"__init__",
"_handle_function",
"_ruleset_directory",
"_run",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self._ruleset_list),))
self._t_timer.daemon = True
self._t_timer.start()
self._d_timer = threading.Timer(0.1, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self.
|
1,706 | 39 | 36,546 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_t_timer
| true |
statement
| 37 | 37 | true | false |
[
"_d_timer",
"_t_timer",
"_ruleset_list",
"get_ruleset",
"assert_fact",
"__init__",
"_handle_function",
"_ruleset_directory",
"_run",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self._ruleset_list),))
self._t_timer.daemon = True
self._t_timer.start()
self._d_timer = threading.Timer(0.1, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
self._t_timer = threading.Timer(0.1, dispatch_timers, (0,))
self.
|
1,707 | 39 | 36,582 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/engine.py
|
Unknown
|
_t_timer
| true |
statement
| 37 | 37 | true | false |
[
"_d_timer",
"_t_timer",
"_ruleset_list",
"get_ruleset",
"assert_fact",
"__init__",
"_handle_function",
"_ruleset_directory",
"_run",
"assert_facts",
"complete_get_idle_state",
"complete_get_queued_messages",
"delete_message_callback",
"delete_state",
"get_action",
"get_facts",
"get_idle_state_callback",
"get_pending_events",
"get_queued_messages_callback",
"get_state",
"get_stored_messages_callback",
"load_ruleset",
"post",
"post_batch",
"queue_message_callback",
"register_rulesets",
"renew_action_lease",
"retract_fact",
"retract_facts",
"save_ruleset",
"set_delete_message_callback",
"set_get_idle_state_callback",
"set_get_queued_messages_callback",
"set_queue_message_callback",
"set_rulesets",
"set_store_message_callback",
"store_message_callback",
"update_state",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "assert_fact",
"type": "function"
},
{
"name": "assert_facts",
"type": "function"
},
{
"name": "complete_get_idle_state",
"type": "function"
},
{
"name": "complete_get_queued_messages",
"type": "function"
},
{
"name": "delete_message_callback",
"type": "statement"
},
{
"name": "delete_state",
"type": "function"
},
{
"name": "get_action",
"type": "function"
},
{
"name": "get_facts",
"type": "function"
},
{
"name": "get_idle_state_callback",
"type": "statement"
},
{
"name": "get_pending_events",
"type": "function"
},
{
"name": "get_queued_messages_callback",
"type": "statement"
},
{
"name": "get_ruleset",
"type": "function"
},
{
"name": "get_state",
"type": "function"
},
{
"name": "get_stored_messages_callback",
"type": "statement"
},
{
"name": "load_ruleset",
"type": "function"
},
{
"name": "post",
"type": "function"
},
{
"name": "post_batch",
"type": "function"
},
{
"name": "queue_message_callback",
"type": "statement"
},
{
"name": "register_rulesets",
"type": "function"
},
{
"name": "renew_action_lease",
"type": "function"
},
{
"name": "retract_fact",
"type": "function"
},
{
"name": "retract_facts",
"type": "function"
},
{
"name": "save_ruleset",
"type": "function"
},
{
"name": "set_delete_message_callback",
"type": "function"
},
{
"name": "set_get_idle_state_callback",
"type": "function"
},
{
"name": "set_get_queued_messages_callback",
"type": "function"
},
{
"name": "set_queue_message_callback",
"type": "function"
},
{
"name": "set_rulesets",
"type": "function"
},
{
"name": "set_store_message_callback",
"type": "function"
},
{
"name": "store_message_callback",
"type": "statement"
},
{
"name": "update_state",
"type": "function"
},
{
"name": "_d_timer",
"type": "statement"
},
{
"name": "_handle_function",
"type": "function"
},
{
"name": "_ruleset_directory",
"type": "statement"
},
{
"name": "_ruleset_list",
"type": "statement"
},
{
"name": "_run",
"type": "function"
},
{
"name": "_t_timer",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import json
import copy
import threading
import inspect
import random
import time
import datetime
import os
import sys
import traceback
from . import logger, durable_rules_engine
def _unix_now():
dt = datetime.datetime.now()
epoch = datetime.datetime.utcfromtimestamp(0)
delta = dt - epoch
return delta.total_seconds()
class MessageNotHandledException(Exception):
def __init__(self, message):
self.message = 'Could not handle message: {0}'.format(json.dumps(message, ensure_ascii=False))
class MessageObservedException(Exception):
def __init__(self, message):
self.message = 'Message has already been observed: {0}'.format(json.dumps(message, ensure_ascii=False))
class Closure(object):
def __init__(self, host, ruleset, state, message, handle):
self.host = host
self.s = Content(state)
self._handle = handle
self._ruleset = ruleset
self._completed = False
self._deleted = False
self._start_time = _unix_now()
if isinstance(message, dict):
self._m = message
else:
self.m = []
for one_message in message:
if ('m' in one_message) and len(one_message) == 1:
one_message = one_message['m']
self.m.append(Content(one_message))
def post(self, ruleset_name, message=None):
if message:
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self.host.assert_event(ruleset_name, message)
else:
message = ruleset_name
if not 'sid' in message:
message['sid'] = self.s.sid
if isinstance(message, Content):
message = message._d
self._ruleset.assert_event(message)
def assert_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.assert_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.assert_fact(fact)
def retract_fact(self, ruleset_name, fact=None):
if fact:
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self.host.retract_fact(ruleset_name, fact)
else:
fact = ruleset_name
if not 'sid' in fact:
fact['sid'] = self.s.sid
if isinstance(fact, Content):
fact = fact._d
self._ruleset.retract_fact(fact)
def start_timer(self, timer_name, duration, manual_reset=False):
self._ruleset.start_timer(self.s.sid, timer_name, duration, manual_reset)
def cancel_timer(self, timer_name):
self._ruleset.cancel_timer(self.s.sid, timer_name)
def renew_action_lease(self):
if _unix_now() - self._start_time < 10:
self._start_time = _unix_now()
self._ruleset.renew_action_lease(self.s.sid)
def delete_state(self):
self._deleted = True
def get_facts(self):
return self._ruleset.get_facts(self.s.sid)
def get_pending_events(self):
return self._ruleset.get_pending_events(self.s.sid)
def _has_completed(self):
if _unix_now() - self._start_time > 10:
self._completed = True
value = self._completed
self._completed = True
return value
def _is_deleted(self):
return self._deleted
def __getattr__(self, name):
if name == '_m':
return None
if name in self._m:
return Content(self._m[name])
else:
return None
class Content(object):
def items(self):
return self._d.items()
def __init__(self, data):
self._d = data
def __getitem__(self, key):
if key in self._d:
data = self._d[key]
if isinstance(data, dict):
data = Content(data)
return data
else:
return None
def __setitem__(self, key, value):
if value == None:
del self._d[key]
elif isinstance(value, Content):
self._d[key] = value._d
else:
self._d[key] = value
def __iter__(self):
return self._d.__iter__
def __contains__(self, key):
return key in self._d
def __getattr__(self, name):
return self.__getitem__(name)
def __setattr__(self, name, value):
if name == '_d':
self.__dict__['_d'] = value
else:
self.__setitem__(name, value)
def __repr__(self):
return repr(self._d)
def __str__(self):
return str(self._d)
class Promise(object):
def __init__(self, func):
self._func = func
self._next = None
self._sync = True
self._timer = None
self.root = self
arg_count = func.__code__.co_argcount
if inspect.ismethod(func):
arg_count -= 1
if arg_count == 2:
self._sync = False
elif arg_count != 1:
raise Exception('Invalid function signature')
def continue_with(self, next):
if (isinstance(next, Promise)):
self._next = next
elif (hasattr(next, '__call__')):
self._next = Promise(next)
else:
raise Exception('Unexpected Promise Type')
self._next.root = self.root
return self._next
def run(self, c, complete):
def timeout(max_time):
if _unix_now() > max_time:
c.s.exception = 'timeout expired'
complete(None)
else:
c.renew_action_lease()
self._timer = threading.Timer(5, timeout, (max_time,))
self._timer.daemon = True
self._timer.start()
if self._sync:
try:
self._func(c)
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
except:
c.s.exception = 'unknown exception'
if self._next:
self._next.run(c, complete)
else:
complete(None)
else:
try:
def callback(e):
if self._timer:
self._timer.cancel()
self._timer = None
if e:
c.s.exception = str(e)
if self._next:
self._next.run(c, complete)
else:
complete(None)
time_left = self._func(c, callback)
if time_left:
self._timer = threading.Timer(5, timeout, (_unix_now() + time_left,))
self._timer.daemon = True
self._timer.start()
except BaseException as error:
t, v, tb = sys.exc_info()
c.s.exception = 'exception caught {0}, traceback {1}'.format(str(error), traceback.format_tb(tb))
complete(None)
except:
c.s.exception = 'unknown exception'
complete(None)
class To(Promise):
def __init__(self, from_state, to_state, assert_state):
super(To, self).__init__(self._execute)
self._from_state = from_state
self._to_state = to_state
self._assert_state = assert_state
def _execute(self, c):
c.s.running = True
if self._from_state != self._to_state:
try:
if self._from_state:
if c.m and isinstance(c.m, list):
c.retract_fact(c.m[0].chart_context)
else:
c.retract_fact(c.chart_context)
if self._assert_state:
c.assert_fact({'label': self._to_state, 'chart': 1})
else:
c.post({'label': self._to_state, 'chart': 1})
except MessageNotHandledException:
pass
class Ruleset(object):
def __init__(self, name, host, ruleset_definition):
self._actions = {}
self._name = name
self._host = host
for rule_name, rule in ruleset_definition.items():
action = rule['run']
del rule['run']
if isinstance(action, str):
self._actions[rule_name] = Promise(host.get_action(action))
elif isinstance(action, Promise):
self._actions[rule_name] = action.root
elif (hasattr(action, '__call__')):
self._actions[rule_name] = Promise(action)
self._handle = durable_rules_engine.create_ruleset(name, json.dumps(ruleset_definition, ensure_ascii=False))
self._definition = ruleset_definition
def _handle_result(self, result, message):
if result[0] == 1:
raise MessageNotHandledException(message)
elif result[0] == 2:
raise MessageObservedException(message)
elif result[0] == 3:
return 0
return result[1]
def assert_event(self, message):
return self._handle_result(
durable_rules_engine.assert_event(self._handle, json.dumps(message, ensure_ascii=False)), message)
def assert_events(self, messages):
return self._handle_result(
durable_rules_engine.assert_events(self._handle, json.dumps(messages, ensure_ascii=False)), messages)
def assert_fact(self, fact):
return self._handle_result(durable_rules_engine.assert_fact(self._handle, json.dumps(fact, ensure_ascii=False)),
fact)
def assert_facts(self, facts):
return self._handle_result(
durable_rules_engine.assert_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def retract_fact(self, fact):
return self._handle_result(
durable_rules_engine.retract_fact(self._handle, json.dumps(fact, ensure_ascii=False)), fact)
def retract_facts(self, facts):
return self._handle_result(
durable_rules_engine.retract_facts(self._handle, json.dumps(facts, ensure_ascii=False)), facts)
def start_timer(self, sid, timer, timer_duration, manual_reset):
if sid != None:
sid = str(sid)
durable_rules_engine.start_timer(self._handle, timer_duration, manual_reset, timer, sid)
def cancel_timer(self, sid, timer_name):
if sid != None:
sid = str(sid)
durable_rules_engine.cancel_timer(self._handle, sid, timer_name)
def update_state(self, state):
state['$s'] = 1
return durable_rules_engine.update_state(self._handle, json.dumps(state, ensure_ascii=False))
def get_state(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_state(self._handle, sid))
def delete_state(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.delete_state(self._handle, sid)
def renew_action_lease(self, sid):
if sid != None:
sid = str(sid)
durable_rules_engine.renew_action_lease(self._handle, sid)
def get_facts(self, sid):
if sid != None:
sid = str(sid)
facts = durable_rules_engine.get_facts(self._handle, sid)
return json.loads(facts)
def get_pending_events(self, sid):
if sid != None:
sid = str(sid)
return json.loads(durable_rules_engine.get_events(self._handle, sid))
def set_store_message_callback(self, func):
durable_rules_engine.set_store_message_callback(self._handle, func)
def set_delete_message_callback(self, func):
durable_rules_engine.set_delete_message_callback(self._handle, func)
def set_queue_message_callback(self, func):
durable_rules_engine.set_queue_message_callback(self._handle, func)
def set_get_stored_messages_callback(self, func):
durable_rules_engine.set_get_stored_messages_callback(self._handle, func)
def set_get_queued_messages_callback(self, func):
durable_rules_engine.set_get_queued_messages_callback(self._handle, func)
def complete_get_queued_messages(self, sid, queued_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_queued_messages(self._handle, sid, queued_messages)
def set_get_idle_state_callback(self, func):
durable_rules_engine.set_get_idle_state_callback(self._handle, func)
def complete_get_idle_state(self, sid, stored_messages):
if sid != None:
sid = str(sid)
durable_rules_engine.complete_get_idle_state(self._handle, sid, stored_messages)
def get_definition(self):
return self._definition
@staticmethod
def create_rulesets(host, ruleset_definitions):
branches = {}
for name, definition in ruleset_definitions.items():
if name.rfind('$state') != -1:
name = name[:name.rfind('$state')]
branches[name] = Statechart(name, host, definition)
elif name.rfind('$flow') != -1:
name = name[:name.rfind('$flow')]
branches[name] = Flowchart(name, host, definition)
else:
branches[name] = Ruleset(name, host, definition)
return branches
def dispatch_timers(self):
return durable_rules_engine.assert_timers(self._handle)
def _flush_actions(self, state, result_container, state_offset, complete):
while 'message' in result_container:
print("RES", result_container)
action_name = None
for action_name, message in result_container['message'].items():
break
del (result_container['message'])
c = Closure(self._host, self, state, message, state_offset)
def action_callback(e):
if c._has_completed():
return
if e:
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(e, None)
else:
try:
j = json.dumps(c.s._d, ensure_ascii=False);
print("HANDLE", self._handle)
print("JSON", j)
next = durable_rules_engine.update_state(self._handle, j)
print("NEXT_STATE", next)
new_result = durable_rules_engine.complete_and_start_action(self._handle, c._handle)
print("NEW_RESULT", self._handle, c._handle, new_result)
if new_result:
result_container['message'] = json.loads(new_result)
else:
complete(None, state)
except BaseException as error:
t, v, tb = sys.exc_info()
logger.exception('base exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete(error, None)
except:
logger.exception('unknown exception type %s, value %s, traceback %s', t, str(v),
traceback.format_tb(tb))
durable_rules_engine.abandon_action(self._handle, c._handle)
complete('unknown error', None)
if c._is_deleted():
try:
self.delete_state(c.s['sid'])
except:
pass
print("ACTION", action_name)
self._actions[action_name].run(c, action_callback)
def do_actions(self, state_handle, complete):
try:
result = durable_rules_engine.start_action_for_state(self._handle, state_handle)
if not result:
complete(None, None)
else:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, state_handle, complete)
except BaseException as error:
complete(error, None)
def dispatch(self):
def callback(error, result):
pass
result = durable_rules_engine.start_action(self._handle)
if result:
self._flush_actions(json.loads(result[0]), {'message': json.loads(result[1])}, result[2], callback)
class Statechart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(None, None, None, chart_definition, ruleset_definition)
super(Statechart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'stateChart'
def _transform(self, parent_name, parent_triggers, parent_start_state, chart_definition, rules):
start_state = {}
reflexive_states = {}
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
start_state[qualified_name] = True
for trigger_name, trigger in state.items():
if ('to' in trigger and trigger['to'] == state_name) or 'count' in trigger or 'cap' in trigger:
reflexive_states[qualified_name] = True
for state_name, state in chart_definition.items():
qualified_name = state_name
if parent_name:
qualified_name = '{0}.{1}'.format(parent_name, state_name)
triggers = {}
if parent_triggers:
for parent_trigger_name, trigger in parent_triggers.items():
triggers['{0}.{1}'.format(qualified_name, parent_trigger_name)] = trigger
for trigger_name, trigger in state.items():
if trigger_name != '$chart':
if ('to' in trigger) and parent_name:
trigger['to'] = '{0}.{1}'.format(parent_name, trigger['to'])
triggers['{0}.{1}'.format(qualified_name, trigger_name)] = trigger
if '$chart' in state:
self._transform(qualified_name, triggers, start_state, state['$chart'], rules)
else:
for trigger_name, trigger in triggers.items():
rule = {}
state_test = {'chart_context': {'$and': [{'label': qualified_name}, {'chart': 1}]}}
if 'pri' in trigger:
rule['pri'] = trigger['pri']
if 'count' in trigger:
rule['count'] = trigger['count']
if 'cap' in trigger:
rule['cap'] = trigger['cap']
if 'all' in trigger:
rule['all'] = list(trigger['all'])
rule['all'].append(state_test)
elif 'any' in trigger:
rule['all'] = [state_test, {'m$any': trigger['any']}]
else:
rule['all'] = [state_test]
if 'run' in trigger:
if isinstance(trigger['run'], str):
rule['run'] = Promise(self._host.get_action(trigger['run']))
elif isinstance(trigger['run'], Promise):
rule['run'] = trigger['run']
elif hasattr(trigger['run'], '__call__'):
rule['run'] = Promise(trigger['run'])
if 'to' in trigger:
from_state = None
if qualified_name in reflexive_states:
from_state = qualified_name
to_state = trigger['to']
assert_state = False
if to_state in reflexive_states:
assert_state = True
if 'run' in rule:
rule['run'].continue_with(To(from_state, to_state, assert_state))
else:
rule['run'] = To(from_state, to_state, assert_state)
if to_state in start_state:
del start_state[to_state]
if parent_start_state and to_state in parent_start_state:
del parent_start_state[to_state]
else:
raise Exception('Trigger {0} destination not defined'.format(trigger_name))
rules[trigger_name] = rule;
started = False
for state_name in start_state.keys():
if started:
raise Exception('Chart {0} has more than one start state {1}'.format(self._name, state_name))
started = True
if parent_name:
rules[parent_name + '$start'] = {
'all': [{'chart_context': {'$and': [{'label': parent_name}, {'chart': 1}]}}],
'run': To(None, state_name, False)};
else:
rules['$start'] = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}],
'run': To(None, state_name, False)};
if not started:
raise Exception('Chart {0} has no start state'.format(self._name))
class Flowchart(Ruleset):
def __init__(self, name, host, chart_definition):
self._name = name
self._host = host
ruleset_definition = {}
self._transform(chart_definition, ruleset_definition)
super(Flowchart, self).__init__(name, host, ruleset_definition)
self._definition = chart_definition
self._definition['$type'] = 'flowChart'
def _transform(self, chart_definition, rules):
visited = {}
reflexive_stages = {}
for stage_name, stage in chart_definition.items():
if 'to' in stage:
if isinstance(stage['to'], str):
if stage['to'] == stage_name:
reflexive_stages[stage_name] = True
else:
for transition_name, transition in stage['to'].items():
if transition_name == stage_name or 'count' in transition or 'cap' in transition:
reflexive_stages[stage_name] = True
for stage_name, stage in chart_definition.items():
stage_test = {'chart_context': {'$and': [{'label': stage_name}, {'chart': 1}]}}
from_stage = None
if stage_name in reflexive_stages:
from_stage = stage_name
if 'to' in stage:
if isinstance(stage['to'], str):
next_stage = None
rule = {'all': [stage_test]}
if stage['to'] in chart_definition:
next_stage = chart_definition[stage['to']]
else:
raise Exception('Stage {0} not found'.format(stage['to']))
assert_stage = False
if stage['to'] in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, stage['to'], assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, stage['to'], assert_stage).continue_with(next_stage['run'])
rules['{0}.{1}'.format(stage_name, stage['to'])] = rule
visited[stage['to']] = True
else:
for transition_name, transition in stage['to'].items():
rule = {}
next_stage = None
if 'pri' in transition:
rule['pri'] = transition['pri']
if 'count' in transition:
rule['count'] = transition['count']
if 'cap' in transition:
rule['cap'] = transition['cap']
if 'all' in transition:
rule['all'] = list(transition['all'])
rule['all'].append(stage_test)
elif 'any' in transition:
rule['all'] = [stage_test, {'m$any': transition['any']}]
else:
rule['all'] = [stage_test]
if transition_name in chart_definition:
next_stage = chart_definition[transition_name]
else:
raise Exception('Stage {0} not found'.format(transition_name))
assert_stage = False
if transition_name in reflexive_stages:
assert_stage = True
if not 'run' in next_stage:
rule['run'] = To(from_stage, transition_name, assert_stage)
else:
if isinstance(next_stage['run'], str):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
Promise(self._host.get_action(next_stage['run'])))
elif isinstance(next_stage['run'], Promise) or hasattr(next_stage['run'], '__call__'):
rule['run'] = To(from_stage, transition_name, assert_stage).continue_with(
next_stage['run'])
rules['{0}.{1}'.format(stage_name, transition_name)] = rule
visited[transition_name] = True
started = False
for stage_name, stage in chart_definition.items():
if not stage_name in visited:
if started:
raise Exception('Chart {0} has more than one start state'.format(self._name))
rule = {'all': [{'chart_context': {'$and': [{'$nex': {'running': 1}}, {'$s': 1}]}}]}
if not 'run' in stage:
rule['run'] = To(None, stage_name, False)
else:
if isinstance(stage['run'], str):
rule['run'] = To(None, stage_name, False).continue_with(
Promise(self._host.get_action(stage['run'])))
elif isinstance(stage['run'], Promise) or hasattr(stage['run'], '__call__'):
rule['run'] = To(None, stage_name, False).continue_with(stage['run'])
rules['$start.{0}'.format(stage_name)] = rule
started = True
class Host(object):
def __init__(self, ruleset_definitions=None):
self._ruleset_directory = {}
self._ruleset_list = []
self.store_message_callback = None
self.delete_message_callback = None
self.queue_message_callback = None
self.get_stored_messages_callback = None
self.get_queued_messages_callback = None
self.get_idle_state_callback = None
if ruleset_definitions:
self.register_rulesets(ruleset_definitions)
self._run()
def get_action(self, action_name):
raise Exception('Action with name {0} not found'.format(action_name))
def load_ruleset(self, ruleset_name):
raise Exception('Ruleset with name {0} not found'.format(ruleset_name))
def save_ruleset(self, ruleset_name, ruleset_definition):
return
def get_ruleset(self, ruleset_name):
if ruleset_name in self._ruleset_directory:
return self._ruleset_directory[ruleset_name]
else:
ruleset_definition = self.load_ruleset(ruleset_name)
self.register_rulesets(ruleset_definition)
return self._ruleset_directory[ruleset_name]
def set_rulesets(self, ruleset_definitions):
self.register_rulesets(ruleset_definitions)
for ruleset_name, ruleset_definition in ruleset_definitions.items():
self.save_ruleset(ruleset_name, ruleset_definition)
def _handle_function(self, rules, func, args, complete):
error = [0]
result = [0]
def callback(e, state):
error[0] = e
result[0] = state
if not complete:
rules.do_actions(func(args), callback)
if error[0]:
raise error[0]
return result[0]
else:
try:
rules.do_actions(func(args), complete)
except BaseException as e:
complete(e, None)
def post(self, ruleset_name, message, complete=None):
if isinstance(message, list):
return self.post_batch(ruleset_name, message)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_event, message, complete)
def post_batch(self, ruleset_name, messages, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_events, messages, complete)
def assert_fact(self, ruleset_name, fact, complete=None):
if isinstance(fact, list):
return self.assert_facts(ruleset_name, fact)
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_fact, fact, complete)
def assert_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.assert_facts, facts, complete)
def retract_fact(self, ruleset_name, fact, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_fact, fact, complete)
def retract_facts(self, ruleset_name, facts, complete=None):
rules = self.get_ruleset(ruleset_name)
return self._handle_function(rules, rules.retract_facts, facts, complete)
def update_state(self, ruleset_name, state, complete=None):
rules = self.get_ruleset(ruleset_name)
self._handle_function(rules, rules.update_state, state, complete)
def get_state(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_state(sid)
def delete_state(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).delete_state(sid)
def renew_action_lease(self, ruleset_name, sid=None):
self.get_ruleset(ruleset_name).renew_action_lease(sid)
def get_facts(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_facts(sid)
def get_pending_events(self, ruleset_name, sid=None):
return self.get_ruleset(ruleset_name).get_pending_events(sid)
def set_store_message_callback(self, func):
self.store_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_store_message_callback(func)
def set_delete_message_callback(self, func):
self.delete_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_delete_message_callback(func)
def set_queue_message_callback(self, func):
self.queue_message_callback = func
for ruleset in self._ruleset_list:
ruleset.set_queue_message_callback(func)
def set_get_queued_messages_callback(self, func):
self.get_queued_messages_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_queued_messages_callback(func)
def complete_get_queued_messages(self, ruleset_name, sid, queued_messages):
self.get_ruleset(ruleset_name).complete_get_queued_messages(sid, queued_messages)
def set_get_idle_state_callback(self, func):
self.get_idle_state_callback = func
for ruleset in self._ruleset_list:
ruleset.set_get_idle_state_callback(func)
def complete_get_idle_state(self, ruleset_name, sid, stored_messages):
self.get_ruleset(ruleset_name).complete_get_idle_state(sid, stored_messages)
def register_rulesets(self, ruleset_definitions):
rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
for ruleset_name, ruleset in rulesets.items():
if ruleset_name in self._ruleset_directory:
raise Exception('Ruleset with name {0} already registered'.format(ruleset_name))
else:
self._ruleset_directory[ruleset_name] = ruleset
self._ruleset_list.append(ruleset)
if self.store_message_callback:
ruleset.set_store_message_callback(self.store_message_callback)
if self.delete_message_callback:
ruleset.set_delete_message_callback(self.delete_message_callback)
if self.queue_message_callback:
ruleset.set_queue_message_callback(self.queue_message_callback)
if self.get_stored_messages_callback:
ruleset.set_get_stored_messages_callback(self.get_stored_messages_callback)
if self.get_queued_messages_callback:
ruleset.set_get_queued_messages_callback(self.get_queued_messages_callback)
if self.get_idle_state_callback:
ruleset.set_get_idle_state_callback(self.get_idle_state_callback)
return list(rulesets.keys())
def _run(self):
def dispatch_ruleset(index):
if not len(self._ruleset_list):
self._d_timer = threading.Timer(0.5, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch()
except BaseException as e:
logger.exception('Error dispatching ruleset')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._d_timer = threading.Timer(timeout, dispatch_ruleset, ((index + 1) % len(self._ruleset_list),))
self._d_timer.daemon = True
self._d_timer.start()
def dispatch_timers(index):
if not len(self._ruleset_list):
self._t_timer = threading.Timer(0.5, dispatch_timers, (0,))
self._t_timer.daemon = True
self._t_timer.start()
else:
ruleset = self._ruleset_list[index]
try:
ruleset.dispatch_timers()
except BaseException as e:
logger.exception('Error dispatching timers')
timeout = 0
if (index == (len(self._ruleset_list) - 1)):
timeout = 0.2
self._t_timer = threading.Timer(timeout, dispatch_timers, ((index + 1) % len(self._ruleset_list),))
self._t_timer.daemon = True
self._t_timer.start()
self._d_timer = threading.Timer(0.1, dispatch_ruleset, (0,))
self._d_timer.daemon = True
self._d_timer.start()
self._t_timer = threading.Timer(0.1, dispatch_timers, (0,))
self._t_timer.daemon = True
self.
|
1,713 | 40 | 319 |
ansible__ansible-rulebook
|
a127c6f286c4e2a906fa9843a644d67ec796dae0
|
ansible_events/drools/lang.py
|
Unknown
|
_set_right
| true |
function
| 7 | 7 | true | true |
[
"_op",
"_left",
"_name",
"_set_right",
"_right",
"__add__",
"__div__",
"__eq__",
"__ge__",
"__getattr__",
"__gt__",
"__init__",
"__le__",
"__lshift__",
"__lt__",
"__mul__",
"__ne__",
"__neg__",
"__pos__",
"__sub__",
"__truediv__",
"_sid",
"define",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "define",
"type": "function"
},
{
"name": "_left",
"type": "statement"
},
{
"name": "_name",
"type": "statement"
},
{
"name": "_op",
"type": "statement"
},
{
"name": "_right",
"type": "statement"
},
{
"name": "_set_right",
"type": "function"
},
{
"name": "_sid",
"type": "statement"
},
{
"name": "__add__",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__div__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__ge__",
"type": "function"
},
{
"name": "__getattr__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__gt__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__le__",
"type": "function"
},
{
"name": "__lshift__",
"type": "function"
},
{
"name": "__lt__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__mul__",
"type": "function"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__neg__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__pos__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
},
{
"name": "__sub__",
"type": "function"
},
{
"name": "__truediv__",
"type": "function"
}
] |
from . import engine, logger
class avalue(object):
def __init__(self, name, left = None, sid = None, op = None, right = None):
self._name = name
self._left = left
self._sid = sid
self._op = op
self._right = right
def __add__(self, other):
return self.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.