def handle_ticktock_to_next_update(force):
t = res_manager.get_next_update_time()
if t < 0:
return False
else:
if force:
while Clock.get() < t:
Clock.tick()
return handle_ticktock(1)
else:
return handle_ticktock(t - Clock.get())
def run_timer():
clk = Clock.get()
if clk not in timers:
return
callback_list = timers[clk]
for callback in callback_list:
callback()
def update(name, cycle=None, param=None):
changed_res_set.add(name)
res = get_res(name)
res.update(param)
if cycle is not None:
add_timer_callback(Clock.get() + cycle(),
lambda: update(name, cycle, param))
class Main(object):
def __init__(self):
logger.info('Starting Bart service')
self.clock = Clock()
self.bart = Bart()
self.display = Display()
signal.signal(signal.SIGINT, self.signal_handler)
signal.signal(signal.SIGTERM, self.signal_handler)
def signal_handler(self, signal, frame):
logger.info('Caught signal {}. Shutting down.'.format(signal))
self.clock.stop()
self.bart.stop()
self.display.stop()
sys.exit(0)
def run(self):
show_clock = False
while True:
if show_clock:
self.display.display(self.clock.get(), True)
else:
self.display.display(self.bart.get(), False)
show_clock = not show_clock
time.sleep(1)
def run_timer():
clk = Clock.get()
if clk not in timers:
return
callback_list = timers[clk]
for callback in callback_list:
callback()
def get_next_update_time():
while len(timers) > 0:
t = min(timers)
if t < Clock.get():
timers.pop(t, None)
else:
return t
return -1
def get_next_update_time():
while len(timers) > 0:
t = min(timers)
if t < Clock.get():
timers.pop(t, None)
else:
return t
return -1
def report_xml(file_name="report.xml", clock=-1):
cur = Clock.get()
if clock < 0:
clock += cur
content = E.content(clock=str(clock))
for name in pool:
value = str(pool.get(name).get_value(clock))
content.insert(0, E.feature(E.name(name), E.currentValue(value)))
with open(file_name, "w") as fout:
fout.write(tostring(content, encoding='utf-8', xml_declaration=True, pretty_print=True))
def report_xml(file_name="report.xml", clock=-1):
cur = Clock.get()
if clock < 0:
clock += cur
content = E.content(clock=str(clock))
for name in pool:
value = str(pool.get(name).get_value(clock))
content.insert(0, E.feature(E.name(name), E.currentValue(value)))
with open(file_name, "w") as fout:
fout.write(tostring(content, encoding='utf-8', xml_declaration=True, pretty_print=True))
def get_value(self, clock=-1):
cur = Clock.get()
if clock < 0:
clock = cur + clock
if clock > cur or clock < 0:
return None
for item in reversed(self.value):
if item[0] <= clock:
return item[1]
def get_value(value, v):
if utils.is_callable(value):
return value()
elif value == "$self":
return v
elif value == "$clock":
return Clock.get()
elif utils.is_string(value) and value.startswith("$"):
return res_manager.get(value[1:])
else:
return value
def get_value(self, clock=-1):
cur = Clock.get()
if clock < 0:
clock = cur + clock
if clock > cur or clock < 0:
return None
for item in reversed(self.value):
if item[0] <= clock:
return item[1]
def get_value_history(self):
values = self.value
clk = Clock.get()
ret = [None] * clk
if values is None or len(values) == 0:
return
idx = 0
pre_value = None
for time, value in values:
while idx < time:
ret[idx] = pre_value
idx += 1
pre_value = value
if time < clk:
ret[time] = value
while idx < clk:
ret[idx] = pre_value
idx += 1
return ret
def get_value_history(self):
values = self.value
clk = Clock.get()
ret = [None] * clk
if values is None or len(values) == 0:
return
idx = 0
pre_value = None
for time, value in values:
while idx < time:
ret[idx] = pre_value
idx += 1
pre_value = value
if time < clk:
ret[time] = value
while idx < clk:
ret[idx] = pre_value
idx += 1
return ret
def report():
print "-----------------------------------------------------"
print "CLOCK:", Clock.get()
res_manager.report()
print "+++++++++++++++++++++++++++++++++++++++++++++++++++++"
def update_delay(name, delay, cycle, param=None):
add_timer_callback(Clock.get() + delay, lambda: update(name, cycle, param))
def set_value(self, value):
clk = Clock.get()
#if len(self.value) > 1 and self.value[-1][0] == clk:
self.value.append((clk, value))
def update_delay(name, delay, cycle, param=None):
add_timer_callback(Clock.get() + delay, lambda: update(name, cycle, param))
def handle_ticktock(time):
ts = int(time * 2)
for i in range(ts):
tick_or_tock()
return Clock.get()
class LamportNode:
def __init__(self, nodes, index):
self.clock = Clock()
self.index = index
self.nodes = {i: n for i, n in nodes.items()}
try:
self.host = nodes[index]["host"]
self.port = int(nodes[index]["port"])
self.chance = float(nodes[index]["chance"])
except KeyError:
raise InvalidNodeError(f"Invalid node {index}")
# Removes own node from the list to avoid sending messages to itself
self.nodes.pop(self.index, None)
self.running = False
self.logger = setup_logger(self.index)
def start(self):
self.running = True
conn_listener = Listener(self.index, self.port, self.clock)
conn_listener.start()
for i in range(constants.EVENTS_COUNT):
if not self.running:
break
sleep(min(random.random() + 0.5, 1))
self.clock.increment()
if random.random() > self.chance:
# local
self.logger.info(f"{perf_counter_ns() // 1000} {self.index} {self.clock.get()}{self.index} l")
else:
# remote
idx, node = self.get_node()
try:
self.send_message(idx, node)
except SocketTimeout:
print(
f"""Error: Timeout sending message to node {idx} ({node["host"]}:{node["port"]})"""
)
break
conn_listener.stop()
def send_message(self, index, node):
node_addr = (node["host"], node["port"])
clock = self.clock.get()
sock = create_socket()
callback_port = bind_random_port(sock)
sock.sendto(
f"{self.index} {clock} {self.host} {callback_port}".encode("utf-8"),
node_addr,
)
wait_response(sock, node_addr, 3.0)
sock.close()
self.logger.info(f"""{perf_counter_ns() // 1000} {self.index} {clock}{self.index} s {index}""")
def get_node(self):
index = random.choice(list(self.nodes.keys()))
return index, self.nodes[index]
def stop(self):
self.running = False
def update(name, cycle=None, param=None):
changed_res_set.add(name)
res = get_res(name)
res.update(param)
if cycle is not None:
add_timer_callback(Clock.get() + cycle(), lambda: update(name, cycle, param))
def get(data, return_type=None):
if type(data) is not dict or "method" not in data:
if return_type is None:
return data
elif return_type == "lambda":
return lambda: data
else:
return None
method = data["method"]
parameter = data["parameter"]
if method.startswith(MATH_PREFIX):
if method == METHOD_MATH_ADD:
a = get(parameter["a"])
b = get(parameter["b"])
method = lambda value: get_value(a, value) + get_value(b, value)
elif method == METHOD_MATH_DIVISION:
a = get(parameter["a"])
b = get(parameter["b"])
method = lambda value: get_value(a, value) / get_value(b, value)
elif method == METHOD_MATH_MINUS:
a = get(parameter["a"])
b = get(parameter["b"])
method = lambda value: get_value(a, value) - get_value(b, value)
elif method == METHOD_MATH_MULTIPLY:
a = get(parameter["a"])
b = get(parameter["b"])
method = lambda value: get_value(a, value) * get_value(b, value)
elif method == METHOD_MATH_MOD:
a = get(parameter["a"])
b = get(parameter["b"])
method = lambda value: get_value(a, value) % get_value(b, value)
elif method == METHOD_MATH_LINEAR:
a = get(parameter["a"])
b = get(parameter["b"])
x = get(parameter["x"])
method = lambda value: get_value(a, value) * get_value(x, value) + get_value(b, value)
elif method == METHOD_MATH_SIN:
a = get(parameter["a"])
b = get(parameter["b"])
x = get(parameter["x"])
method = lambda value: get_value(a, value) * math.sin(get_value(x, value)) + get_value(b, value)
elif method == METHOD_MATH_LOG:
a = get(parameter["a"])
b = get(parameter["b"])
x = get(parameter["x"])
method = lambda value: get_value(a, value) * math.log(get_value(x, value)) + get_value(b, value)
elif method == METHOD_MATH_MEAN:
terms = parameter["term"]
method = lambda value: 1.0 * sum([get_value(term, value) for term in terms]) / len(terms)
elif method == METHOD_MATH_SUM:
terms = parameter["term"]
#print terms
method = lambda value: sum([get_value(term, value) for term in terms])
else:
print "not support method:", method
elif method.startswith(PROBABILITY_PREFIX):
if method == METHOD_PROBABILITY_MARKOV_CHAIN:
state_set = parameter["state_set"]
init_state = parameter["init_state"]
trans_matrix = parameter["trans_matrix"]
method = lambda value: markov_chain(value, state_set, init_state, trans_matrix)
elif method == METHOD_PROBABILITY_NORMAL_VARIATE_RAND:
mu = get(parameter["mu"])
sigma = get(parameter["sigma"])
method = lambda value: normalvariate(get_value(mu, value), get_value(sigma, value))
elif method == METHOD_PROBABILITY_SIMPLE_RAND:
min_value = get(parameter["min"])
max_value = get(parameter["max"])
method = lambda value: randint(get_value(min_value, value), get_value(max_value, value))
else:
print "not support method:", method
else:
if method == METHOD_OTHERS_COMBINE:
sections = parameter["section"]
# print "sections:", sections
method = lambda value: dict((section, get_value(section, value)) for section in sections)
elif method == METHOD_OTHERS_DATA_LIST:
data_list = parameter["data_list"]
method = lambda value: data_list[Clock.get() % len(data_list)]
else:
print "not support method:", method
return method
def set_value(self, value):
clk = Clock.get()
#if len(self.value) > 1 and self.value[-1][0] == clk:
self.value.append((clk, value))
