def homepage():
statusMsg = Message("getData")
webGUIData = parseWebGUIDataMessage(ActorSystem().ask(
aSys.createActor(WebGUI, globalName='WebGUISingleton'),
statusMsg.encode(), 60))
templateData = {
'time':
webGUIData.webGUIData.time,
'envData':
webGUIData.webGUIData.envData,
'triggerTemperature':
webGUIData.webGUIData.triggerTemperature,
'triggerHumidity':
webGUIData.webGUIData.triggerHumidity,
'lightStatus':
"ON" if webGUIData.webGUIData.envData.lightOn else "OFF",
'currentOn':
datetime.datetime.strftime(
webGUIData.webGUIData.lightSchedule.currentOn, "%H:%M"),
'currentOff':
datetime.datetime.strftime(
webGUIData.webGUIData.lightSchedule.currentOff, "%H:%M"),
'upcomingOn':
datetime.datetime.strftime(
webGUIData.webGUIData.lightSchedule.upcomingOn, "%H:%M"),
'upcomingOff':
datetime.datetime.strftime(
webGUIData.webGUIData.lightSchedule.upcomingOff, "%H:%M")
}
return render_template("homepage.html", **templateData)
def run_node(self):
round = self.env.get_round()
myid = self.env.get_id(self)
if round == 0:
if self.env.get_id(self) == NaiveVoting.SENDER:
self.input = self.env.get_input(self)
self.env.put_broadcast(self, self.pki.sign(
self, Message(myid, self.input)))
elif round == 1:
msgs = self.env.get_input_msgs(self)
for msg in msgs:
if self.pki.verify(msg) and msg.get_sender() == NaiveVoting.SENDER and (
msg.get_extraction() == 0 or msg.get_extraction() == 1):
self.env.put_broadcast(
self, self.pki.sign(self, Message(myid, msg)))
elif round == 2:
msgs = self.env.get_input_msgs(self)
seen = set()
cnt = [0, 0]
for msg in msgs:
if self.pki.verify(msg) and (msg.get_sender() not in seen) and (
msg.get_extraction() == 0 or msg.get_extraction() == 1):
seen.add(msg.get_sender())
cnt[msg.get_extraction()] += 1
bar = self.env.get_n() * 2 / 3
if cnt[0] >= bar:
self.env.put_output(self, 0)
elif cnt[1] >= bar:
self.env.put_output(self, 1)
else:
self.env.put_output(self, None)
else:
raise RuntimeError
def run_node(self):
round = self.env.get_round()
myid = self.env.get_id(self)
if round == 0:
if self.env.get_id(self) == DolevStrong.SENDER:
self.input = self.env.get_input(self)
self.env.put_broadcast(
self, self.pki.sign(self, Message(myid, self.input)))
self.seen[self.input] = True
elif 1 <= round <= self.env.get_tf():
msgs = self.env.get_input_msgs(self)
for msg in msgs:
if self.pki.verify(msg) and self.my_verify(round, msg):
b = msg.get_extraction()
if (b == 0 or b == 1) and not self.seen[b]:
self.seen[b] = True
self.env.put_broadcast(
self, self.pki.sign(self, Message(myid, msg)))
if round == self.env.get_tf():
if self.seen[1] and not self.seen[0]:
self.env.put_output(self, 1)
else:
self.env.put_output(self, 0)
else:
raise RuntimeErro
def mine_block(self):
myid = self.env.get_id(self)
new_block = Nakamoto_Block(
self.block_forest.query_max_depth_block_id(), miner=myid)
self.env.insert_block(new_block)
self.block_forest.insert(new_block)
self.env.put_broadcast(
self, myid, self.pki.sign(self, Message(myid, new_block, round)))
self.env.dispatch_message()
def receive_block(self):
msgs = self.env.get_input_msg(self.chameleon_dict[self.represent_id])
if not msgs:
return
for msg in msgs:
block = msg.get_extraction()
if not self.public_block_forest.block_is_in(block):
self.public_block_forest.insert(block)
self.private_chain_len = len(self.private_block_forest.get_chain())
self.public_chain_len = len(self.public_block_forest.get_chain())
if self.public_chain_len > self.private_chain_len:
self.private_block_forest = self.public_block_forest.clone()
pass
else:
if self.private_chain_len - self.public_chain_len == 1:
for i in range(len(self.private_blocks)):
block = self.private_blocks.pop()
self.env.put_broadcast(
self, self.represent_id,
self.pki.sign(
self.chameleon_dict[self.represent_id],
Message(self.represent_id, block, round)))
self.public_block_forest = self.private_block_forest.clone(
)
self.con.dispatch_honest_message()
self.con.throw_adv_message()
elif self.private_chain_len - self.public_chain_len == 0:
for i in range(len(self.private_blocks)):
block = self.private_blocks.pop()
self.env.put_broadcast(
self, self.represent_id,
self.pki.sign(
self.chameleon_dict[self.represent_id],
Message(self.represent_id, block, round)))
if not self.public_block_forest.block_is_in(block):
self.public_block_forest.insert(block)
self.con.dispatch_honest_message()
self.con.throw_adv_message()
else:
pass
def run_node(self):
round = self.env.get_round()
myid = self.env.get_id(self)
flag = 0
if round == 0:
self.input = self.env.get_input(myid)
self.env.put_broadcast(self, self.pki.sign(
self, Message(myid, self.input)))
else:
if flag:
self.env.get_input_msgs(self)
self.env.put_broadcast(self, self.pki.sign(
self, Message(myid, self.input)))
else:
msgs = self.env.get_input_msgs(self)
d = {}
for msg in msgs:
if(not self.pki.verify(msg)):
raise RuntimeError
key = msg.get_extraction()
if key not in d:
d[key] = 0
d[key] = d[key]+1
if not d:
raise RuntimeError
d_sorted = sorted(
d.items(), key=lambda kv: kv[1], reverse=True)
if(d_sorted[0][1] >= (self.env.get_n()-self.env.get_f())):
self.env.put_output(self, d_sorted[0][0])
self.input = d_sorted[0][0]
self.env.put_broadcast(self, self.pki.sign(
self, Message(myid, self.input)))
elif (d_sorted[0][1] > (self.env.get_n()-self.env.get_f())/2):
if len(d_sorted) > 1 and d_sorted[1][1] > (self.env.get_n()-self.env.get_f())/2:
self.env.put_broadcast(self, self.pki.sign(
self, Message(myid, self.input)))
else:
self.input = d_sorted[0][0]
self.env.put_broadcast(self, self.pki.sign(
self, Message(myid, self.input)))
def run_node(self):
running_round = self.env.get_round()
msgs = self.env.get_input_msgs(self.represent_node)
for msg in msgs:
if (not self.pki.verify(msg)):
raise RuntimeError
if msg.sender == self.represent_id:
continue
new_site = msg.get_extraction().copy()
if not new_site:
raise RuntimeError
self.Tangle.insert_site(new_site)
for site in self.chameleon_dict.values():
my_pow = True
if my_pow:
new_site = Tangle_Site([], [], self.represent_id, None, [], 0)
self.my_sites.append(new_site)
weight1 = self.Tangle.genesis_site.children_list[
0].calculate_cumulative_weight()
weight0 = self.Tangle.genesis_site.children_list[
1].calculate_cumulative_weight()
if weight0 == weight1:
if len(self.my_sites) > self.limit:
self.equal_add(running_round)
return
else:
if weight0 > weight1:
indicator = 0
else:
indicator = 1
delta = abs(weight0 - weight1) + round(
(self.con.n - self.con.tf) * abs(weight0 - weight1) /
(weight0 + weight1))
for i in range(min(delta, len(self.my_sites))):
balance_site = self.my_sites.pop()
balance_site.vote = 1 - indicator
balance_site.father_id_list = [2 + indicator]
balance_site.father_list.append(
self.Tangle.genesis_site.children_list[indicator])
balance_site.update_weight()
self.Tangle.id_node_map[balance_site.id] = balance_site
signed_site = self.pki.sign(self.represent_node, balance_site)
self.Tangle.genesis_site.children_list[
indicator].children_list.append(signed_site)
self.env.put_broadcast(
self.represent_node,
self.pki.sign(
self.represent_node,
Message(self.represent_id, signed_site,
running_round)))
if len(self.my_sites) > self.limit:
self.equal_add(running_round)
def run_node(self):
round = self.env.get_round()
myid = self.env.get_id(self)
if round == 0:
self.belief = self.env.get_input(myid)
pass
elif round <= self.bar:
msgs = self.env.get_input_msgs(self)
bucket_lists = [[], []]
for msg in msgs:
if (not self.pki.verify(msg)):
raise RuntimeError
bucket = msg.get_extraction()
if not bool(bucket):
bool(bucket)
raise RuntimeError
if self.bucket_verify(bucket):
bucket_lists[bucket[0].belief].append(bucket.copy())
for bucket in self.buckets:
if bucket:
bucket_lists[bucket[0].belief].append(bucket.copy())
for bucket_list in bucket_lists:
if bucket_list:
self.buckets[bucket_list[0][0].belief] = max(
bucket_list, key=lambda x: len(x))
l0 = len(self.buckets[0])
l1 = len(self.buckets[1])
if l0 != 0 or l1 != 0:
if (l0 > l1) or (l0 == l1):
self.belief = 0
else:
self.belief = 1
if round == self.bar:
self.env.put_output(self, self.belief)
return
my_pow = self.my_mine.POW(round, myid, self.belief)
if my_pow:
new_block = self.pki.sign(self, Block(round, myid,
self.belief))
self.buckets[self.belief].append(new_block)
self.env.put_broadcast(
self,
self.pki.sign(
self,
Message(myid, (self.buckets[self.belief]).copy(),
round)))
def run_node(self):
round = self.env.get_round()
if round > self.running_rounds:
return
if round == self.running_rounds:
self.env.put_output(self, self.plotdata)
return
myid = self.env.get_id(self)
msgs = self.env.get_input_msgs(self)
for msg in msgs:
if (not self.pki.verify(msg)):
raise RuntimeError
if msg.sender == myid:
continue
new_site = msg.get_extraction().copy()
if not new_site:
raise RuntimeError
self.Tangle.insert_site(new_site)
my_pow = self.mine.POW(round, myid)
if my_pow:
selected_tips = self.Tangle.random_walk()
if selected_tips[0].vote != selected_tips[1].vote:
raise RuntimeError
if selected_tips[0] == selected_tips[1]:
del selected_tips[1]
father_id_list = []
father_list = []
for tip in selected_tips:
father_id_list.append(tip.id)
for tip in selected_tips:
father_list.append(tip)
new_site = self.pki.sign(
self,
Tangle_Site(father_id_list, [], myid, selected_tips[0].vote,
father_list, 0))
for tip in selected_tips:
if new_site in tip.children_list:
continue
tip.children_list.append(new_site)
new_site.update_weight()
self.Tangle.id_node_map[new_site.id] = new_site
self.env.put_broadcast(
self, self.pki.sign(self, Message(myid, new_site, round)))
self.update_plotdata()
def equal_add(self, running_round):
add_num = math.ceil((len(self.my_sites) - self.limit) / 2)
for i in range(add_num):
for indicator in range(2):
balance_site = self.my_sites.pop()
balance_site.vote = 1 - indicator
balance_site.father_id_list = [2 + indicator]
balance_site.father_list.append(
self.Tangle.genesis_site.children_list[indicator])
balance_site.update_weight()
self.Tangle.id_node_map[balance_site.id] = balance_site
signed_site = self.pki.sign(self.represent_node, balance_site)
self.Tangle.genesis_site.children_list[
indicator].children_list.append(signed_site)
self.env.put_broadcast(
self.represent_node,
self.pki.sign(
self.represent_node,
Message(self.represent_id, signed_site,
running_round)))
def run_node(self):
round = self.env.get_round()
myid = self.env.get_id(self)
if round == 0:
self.belief = self.env.get_input(myid)
elif round <= self.bar:
msgs = self.env.get_input_msgs(self)
bucket_lens = [len(self.buckets[0]), len(self.buckets[1])]
for msg in msgs:
if not self.pki.verify(msg):
raise RuntimeError
bucket = msg.get_extraction()
if not bucket:
raise RuntimeError
if self.bucket_verify(bucket, round) and len(bucket) > len(
self.buckets[bucket[0].belief]):
self.buckets[bucket[0].belief] = bucket
l0 = len(self.buckets[0])
l1 = len(self.buckets[1])
if l0 != 0 or l1 != 0:
if (l0 > l1) or (l0 == l1):
self.belief = 0
else:
self.belief = 1
if round == self.bar:
self.env.put_output(self, self.belief)
return
my_pow = self.my_mine.POW(round, myid, self.belief)
if my_pow:
new_block = self.pki.sign(self, Block(round, myid,
self.belief))
self.buckets[self.belief] = self.buckets[self.belief].copy()
self.buckets[self.belief].append(new_block)
for i in range(2):
if len(self.buckets[i]) > bucket_lens[i]:
self.env.put_broadcast(
self,
self.pki.sign(self,
Message(myid, self.buckets[i], round)))
def ToggleLightStatus():
webGUI = ActorSystem().createActor(WebGUI, globalName='WebGUISingleton')
ActorSystem().tell(webGUI, Message("ToggleLightStatus").encode())
return redirect('/')
# sys.exit(0)
# asys = ActorSystem('simpleSystemBase')
# Setup this system as the convention leader, and give it a capability "Server"
# Note by default actor systems use port 1900, so we'll set this here too
# capabilities = {"Convention Address.IPv4": (get_my_ip(), 1900)}
# aSys = ActorSystem("multiprocTCPBase", capabilities)
# aSys = ActorSystem('simpleSystemBase')
aSys = ActorSystem('multiprocQueueBase')
webGUI = aSys.createActor(WebGUI, globalName='WebGUISingleton')
loggingActor = aSys.createActor(LoggingActor)
envCtrl = aSys.createActor(EnvironmentController)
launchMsg = Message("Launch")
ActorSystem().tell(envCtrl, launchMsg.encode())
msg = SysLogMessage("INFO", "System launched")
ActorSystem().tell(loggingActor, msg.encode())
msg = DataLogMessage(21, 53, True, True)
ActorSystem().tell(loggingActor, msg.encode())
actorAddrMsg = ActorAddressMessage(webGUI, envCtrl, loggingActor)
ActorSystem().tell(webGUI, actorAddrMsg.encode())
ActorSystem().tell(envCtrl, actorAddrMsg.encode())
ActorSystem().tell(loggingActor, actorAddrMsg.encode())
msg = Message("StartEnvironmentTasks")
ActorSystem().tell(envCtrl, msg.encode())
def receiveMessage(self, message, sender):
msg = parseMessage(message)
if msg.name == "ActorAddress":
msg = parseActorAddressMessage(message)
self.loggingAddr = msg.loggingAddr
self.webGUIAddr = msg.webGUIAddr
elif msg.name == "Launch":
self.fanCtrlAddr = self.createActor(FanController)
self.climRdrAddr = self.createActor(ClimateReader)
self.lightCtrlAddr = self.createActor(LightController)
elif msg.name == "StartEnvironmentTasks":
fanCtrlMessage = Message("UpdateFanStatus")
self.scheduleMsg(self.fanCtrlAddr, fanCtrlMessage.encode(), 30)
lightCtrlMessage = Message("UpdateLightStatus")
self.scheduleMsg(self.lightCtrlAddr, lightCtrlMessage.encode(), 30)
climRdrMessage = Message("UpdateClimateStatus")
self.scheduleMsg(self.climRdrAddr, climRdrMessage.encode(), 30)
environmentDataMsg = Message("UpdateEnvironmentData")
self.scheduleMsg(self.myAddress, environmentDataMsg.encode(), 30)
elif msg.name == "ClimateData":
msg = parseClimateDataMessage(message)
self.logInfo("Environment Received Climate Temp, Humidity : " +
str(msg.climateData.temperature) + ", " +
str(msg.climateData.humidity))
if (msg.climateData.temperature > self.triggerClimateData.temperature) or\
(msg.climateData.humidity > self.triggerClimateData.humidity):
self.logWarning("Overheating! Turning fan on")
self.overheated = True
self.send(self.fanCtrlAddr, UpdateFanLevelMessage(5).encode())
elif self.overheated and\
(msg.climateData.temperature < (self.triggerClimateData.temperature - 3)) and\
(msg.climateData.humidity < (self.triggerClimateData.humidity - 5)):
self.logInfo("Temperature has returned to suitable levels")
self.overheated = False
self.send(self.fanCtrlAddr,
UpdateFanLevelMessage(self.fanLevel).encode())
self.envData.climateData = msg.climateData
elif msg.name == "FanLevel":
msg = parseFanLevelMessage(message)
self.logInfo("Environment Received Fan Level : " +
str(msg.fanLevel))
self.envData.fanLevel = msg.fanLevel
elif msg.name == "LightData":
msg = parseLightDataMessage(message)
self.envData.lightOn = msg.lightOn
elif msg.name == "UpdateEnvironmentData":
msg = EnvironmentDataMessage(self.envData)
self.send(self.webGUIAddr, msg.encode())
self.send(self.loggingAddr, msg.encode())
elif msg.name == "LightScheduleComplete":
self.logInfo("LightScheduleComplete")
self.send(self.webGUIAddr, message)
replyMsg = LightScheduleMessage(self.lightSchedule.upcomingOn,
self.lightSchedule.upcomingOff)
self.send(self.lightCtrlAddr, replyMsg.encode())
elif msg.name == "LightScheduleStarted":
self.logInfo("LightScheduleStarted")
elif msg.name == "LightSchedule":
msg = parseLightScheduleMessage(message)
self.lightSchedule.currentOn = msg.lightOn[0]
self.lightSchedule.currentOff = msg.lightOff[0]
self.lightSchedule.upcomingOn = msg.lightOn[1]
self.lightSchedule.upcomingOff = msg.lightOff[1]
fwMsg = LightScheduleMessage(self.lightSchedule.currentOn,
self.lightSchedule.currentOff)
self.send(self.lightCtrlAddr, fwMsg.encode())
elif msg.name == "UpdateLight":
self.send(self.lightCtrlAddr, message)
elif msg.name == "UpdateFanLevel":
msg = parseUpdateFanLevelMessage(message)
self.fanLevel = msg.fanLevel
self.send(self.fanCtrlAddr, message)
elif msg.name == "TriggerClimateData":
msg = parseTriggerClimateDataMessage(message)
self.logInfo("Trigger climate temperature set to " +
str(msg.triggerTemperature))
self.logInfo("Trigger climate humidity set to " +
str(msg.triggerHumidity))
self.triggerClimateData.temperature = msg.triggerTemperature
self.triggerClimateData.humidity = msg.triggerHumidity
else:
return
def run_node(self):
if self.env.get_f() == 0:
return
self.called += 1
if (self.called % self.con.f) != 1:
return
round = self.env.get_round()
if round == 0:
pass
elif round < self.bar:
current_buckets = [[], []]
msgs = self.env.get_input_msgs(self.represent_node)
for chameleon in self.chameleon_dict.values():
self.env.get_input_msgs(chameleon)
for msg in msgs:
bucket = msg.get_extraction()
if not bucket:
raise RuntimeError
b = bucket[0].belief
if len(bucket) > len(current_buckets[b]):
current_buckets[b] = bucket
l = [len(current_buckets[0]), len(current_buckets[1])]
for i in self.good_node_list:
for j in range(2):
self.node_receive_bucket_len[i][j] = max(
l[j], self.node_receive_bucket_len[i][j])
for i in range(2):
if len(current_buckets[i]) > len(self.buckets[i]):
self.buckets[i] = current_buckets[i]
for i in self.good_node_list:
if self.node_receive_bucket_len[i][
0] == 0 and self.node_receive_bucket_len[i][1] == 0:
continue
if self.node_receive_bucket_len[i][
0] >= self.node_receive_bucket_len[i][1]:
# current belief of node i is 0
self.predict_node_belief[i] = 0
else:
# current belief of node i is 1
self.predict_node_belief[i] = 1
for i in range(2):
for id in self.corrupt_node_list:
my_pow = self.pow_info[round][id][i]
if my_pow:
new_block = self.pki.sign(self.represent_node,
Block(round, id, i))
self.buckets[i] = self.buckets[i].copy()
self.buckets[i].append(new_block)
break
# the max len of the bucket that all honest nodes will receive in next round
predict_bucketslen = self.bak_len
for i in self.good_node_list:
b = self.predict_node_belief[i]
if self.pow_info[round][i][b]:
predict_bucketslen[b] = max(
predict_bucketslen[b],
self.node_receive_bucket_len[i][b] + 1)
for i in self.good_node_list:
self.node_receive_bucket_len[i][0] = max(
self.node_receive_bucket_len[i][0], predict_bucketslen[0])
self.node_receive_bucket_len[i][1] = max(
self.node_receive_bucket_len[i][1], predict_bucketslen[1])
if self.node_receive_bucket_len[i][
0] == 0 and self.node_receive_bucket_len[i][1] == 0:
continue
if self.node_receive_bucket_len[i][
0] >= self.node_receive_bucket_len[i][1]:
self.predict_node_belief[i] = 0
else:
self.predict_node_belief[i] = 1
if round < self.bar - 1:
for i in self.good_node_list:
b = self.predict_node_belief[b]
tosend = []
if b == 0 and self.pow_info[
round +
1][i][0] == 1 and self.pow_info[round +
1][i][1] == 0:
if len(self.buckets[1]
) > self.node_receive_bucket_len[i][0]:
tosend = self.buckets[
1][:self.node_receive_bucket_len[i][0] + 1]
elif b == 1 and self.pow_info[
round +
1][i][1] == 1 and self.pow_info[round +
1][i][0] == 0:
if len(self.buckets[0]) > 0 and len(
self.buckets[0]
) >= self.node_receive_bucket_len[i][1]:
tosend = self.buckets[
0][:self.node_receive_bucket_len[i][1]]
if tosend:
self.represent_node.env.put_packet(
self.represent_node,
self.represent_node.pki.sign(
self.represent_node,
Message(self.represent_id, tosend)), i)
self.node_receive_bucket_len[i][1 - b] = len(tosend)
self.bak_len[1 - b] = max(self.bak_len[1 - b],
len(tosend))
else:
can0 = []
can1 = []
for i in self.good_node_list:
if (len(self.buckets[0]) > 0 and len(self.buckets[0]) >=
self.node_receive_bucket_len[i][1]
) or self.predict_node_belief[i] == 0:
can0.append(i)
if len(self.buckets[1]) > self.node_receive_bucket_len[i][
0] or self.predict_node_belief[i] == 1:
can1.append(i)
if can0 and can1:
flag = False
for t0 in can0:
for t1 in can1:
if t0 != t1:
if self.predict_node_belief[t0] == 1:
self.represent_node.env.put_packet(
self.represent_node,
self.represent_node.pki.sign(
self.represent_node,
Message(self.represent_id,
self.buckets[0])), t0)
if self.predict_node_belief[t1] == 0:
self.represent_node.env.put_packet(
self.represent_node,
self.represent_node.pki.sign(
self.represent_node,
Message(self.represent_id,
self.buckets[1])), t1)
flag = True
break
if flag:
break