def __init__(self, feed_layer):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
self.feed_layer = feed_layer
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
def __init__(self):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
self.feed = feed.FEED("Feed.pcap", None, None, True)
def __init__(self, feed_layer):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
self.feed_layer = feed_layer
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
self.verbose = 1 # write a lot of comments
self.gossip_wait = 50
def __init__(self):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
#self.events_list = ["1", "2", "3"]
self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"],
[3, "Hallo4"], [4, "Hallo3"], [5, "Hallo4"]]
#length = str(len(events_list))
self.incoming_data = []
self.incoming_ack = []
#learn rsii from incoming messages
_thread.start_new_thread(self.gssp_send_broadcast, ())
def __init__(self, feed_layer, sensor_layer):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
self.feed_layer = feed_layer
self.sensor_layer = sensor_layer
self.sensor_fid = self.sensor_layer.getFid()
self.sensor_cfid = self.sensor_layer.getCfid()
self.currentSwitch = self.sensor_layer.switchState()
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
self.verbose = 0 # write a lot of comments
self.gossip_wait = int(self.sensor_layer.getFrequency() / 2)
self.send_gossip()
def __init__(self):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
self.create_keyfile()
self.fid, self.signer = self.load_keyfile("secret.key")
self.feed = feed.FEED("Feed.pcap", self.fid, self.signer, True)
self.content = "['chat', 'Hi Bob 1']"
self.feed.write(eval(self.content))
self.content = "['chat', 'Hi Bob 2']"
self.feed.write(eval(self.content))
self.content = "['chat', 'Hi Bob 3']"
self.feed.write(eval(self.content))
class Lora_Sync_Layer:
def __init__(self):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
self.create_keyfile()
self.fid, self.signer = self.load_keyfile("secret.key")
self.feed = feed.FEED("Feed.pcap", self.fid, self.signer, True)
self.content = "['chat', 'Hi Bob 1']"
self.feed.write(eval(self.content))
self.content = "['chat', 'Hi Bob 2']"
self.feed.write(eval(self.content))
self.content = "['chat', 'Hi Bob 3']"
self.feed.write(eval(self.content))
def receive_msg_cb(self, msg):
self.decode_msg(msg)
def decode_msg(self, msg):
control_int = msg[0] * 1
#msg = str(msg, "utf-8")
if (control_int == 0):
print("New Gossip")
feed_len_int = msg[1] * 256 + msg[2]
self.handle_incoming_gossip(feed_len_int)
elif (control_int == 1):
print("New Event")
data = msg[1:len(msg)]
self.handle_incoming_event(data)
def handle_incoming_gossip(self, msg):
print("Handle incoming gossip")
if (msg < len(self.feed)):
print("Sending event " + str(msg))
search = msg + 1
for e in self.feed:
signature1 = e.get_metabits(self.signer.get_sinfo())
print(str(e))
if (e.seq == search):
e_trans = e
print("Sync Layer | Sending event:" + str(e.content()))
signature = e_trans.get_metabits(self.signer.get_sinfo())
e_wired = e_trans.to_wire(signature)
print(len(e_wired))
control_b = (1).to_bytes(1, 'big')
self.send_event(control_b + e_wired)
#wait random time before sending
def handle_incoming_event(self, msg):
incoming_event = msg
print(str(incoming_event))
#if (incoming_event[0] == len(self.events_list)): #check if already appended
#self.events_list.append(incoming_event)
#print("Acquired event:" + str(incoming_event[0]))
self.feed._append(msg)
print("Sync Layer | Feed length:" + str(len(self.feed)))
#if data is needed automatically append data.
#else if it could be used later, store to a buffer.
#check if data usefull and append to feeds or append to buffer if event in between is missing
def send_event(self, msg):
self.link_layer.append_msg_to_pipeline(msg, False)
#events einzeln senden? Wie gross können einzelne Nachrichten sein?
def send_gossip(self):
while True:
random = int.from_bytes(os.urandom(1), "big")
gossip_waiting = 5 + math.floor(random / 256 * 5)
print(gossip_waiting)
time.sleep(gossip_waiting)
control_b = (0).to_bytes(1, 'big')
feed_len = len(self.feed)
feed_len_b = feed_len.to_bytes(2, 'big')
gossip = control_b + feed_len_b
#a = str(gossip[0], 'big')
#b = str(gossip[1:2], 'big')
feed_len_int = feed_len_b[0] * 256 + feed_len_b[1]
control_int = control_b[0] * 1
print("Sync Layer | Send gossip: " + str(control_int) + " " +
str(feed_len_int))
#print("Sync Layer | Feed lenght: " + str(len(self.feed)))
#msg = "gssp-bc//" + str(feed_len)
#print(msg)
self.link_layer.append_msg_to_pipeline(gossip, False)
def create_keyfile(self):
h = crypto.HMAC("md5")
h.create()
print("# new HMAC_MD5: share it ONLY with trusted peers")
print('{\n ' + (',\n '.join(h.as_string().split(','))[1:-1]) + '\n}')
keyfile = '{\n ' + (',\n '.join(
h.as_string().split(','))[1:-1]) + '\n}'
f = open('secret.key', 'w')
f.write(keyfile)
f.close()
def load_keyfile(self, fn):
with open(fn, 'r') as f:
key = eval(f.read())
if key['type'] == 'hmac_md5':
#fid = bytes.fromhex(key['feed_id'])
fid = binascii.unhexlify(key['feed_id'])
#signer = crypto.HMAC256(bytes.fromhex(key['private']))
signer = crypto.HMAC("md5", binascii.unhexlify(key['private']))
return fid, signer
class Lora_Sync_Layer:
def __init__(self, feed_layer):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
self.feed_layer = feed_layer
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
def receive_msg_cb(self, msg):
self.decode_msg(msg)
def decode_msg(self, msg):
control_int = msg[0] * 1
#msg = str(msg, "utf-8")
if (control_int == 0):
print("Sync Layer | New gossip received")
feed_len_int = msg[1] * 256 + msg[2]
self.handle_incoming_gossip(feed_len_int)
elif (control_int == 1):
print("Sync Layer | New event received")
data = msg[1:len(msg)]
self.handle_incoming_event(data)
def handle_incoming_gossip(self, msg):
print("Sync Layer | Handle incoming gossip")
fid = self.feed_layer.get_sensor_feed_fid()
if (msg < self.feed_layer.get_feed_length(fid)):
print("Sync Layer | Sending event nr " + str(msg))
search = msg + 1
e_wired = self.feed_layer.get_wired_event(fid, search)
print("Sync Layer | Sending event: Length=" + str(len(e_wired)))
control_b = (1).to_bytes(1, 'big')
#wait random time before sending
self.send_event(control_b + e_wired)
def handle_incoming_event(self, msg):
print("Sync Layer | Event data: " + str(msg))
#if (incoming_event[0] == len(self.events_list)): #check if already appended
#self.events_list.append(incoming_event)
#print("Acquired event:" + str(incoming_event[0]))
fid = self.feed_layer.get_sensor_feed_fid()
self.feed_layer.append(fid, msg)
print("Sync Layer | Feed length:" +
str(self.feed_layer.get_feed_length(fid)))
#if data is needed automatically append data.
#else if it could be used later, store to a buffer.
#check if data usefull and append to feeds or append to buffer if event in between is missing
def send_event(self, msg):
self.link_layer.append_msg_to_pipeline(msg, False)
#events einzeln senden? Wie gross können einzelne Nachrichten sein?
def send_gossip(self):
while True:
random = int.from_bytes(os.urandom(1), "big")
gossip_waiting = 5 + math.floor(random / 256 * 5)
print(gossip_waiting)
time.sleep(gossip_waiting)
control_b = (0).to_bytes(1, 'big')
fid = self.feed_layer.get_sensor_feed_fid()
feed_len = self.feed_layer.get_feed_length(fid)
feed_len_b = feed_len.to_bytes(2, 'big')
gossip = control_b + feed_len_b
#a = str(gossip[0], 'big')
#b = str(gossip[1:2], 'big')
feed_len_int = feed_len_b[0] * 256 + feed_len_b[1]
control_int = control_b[0] * 1
print("Sync Layer | Send gossip: " + str(control_int) + " " +
str(feed_len_int))
#print("Sync Layer | Feed lenght: " + str(len(self.feed)))
#msg = "gssp-bc//" + str(feed_len)
#print(msg)
self.link_layer.append_msg_to_pipeline(gossip, False)
class Lora_Sync_Layer:
def __init__(self, feed_layer):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
self.feed_layer = feed_layer
#self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"], [3, "Hallo4"]]
_thread.start_new_thread(self.send_gossip, ())
self.verbose = 0 # write a lot of comments
self.gossip_wait = 8
def receive_msg_cb(self, msg):
self.decode_msg(msg)
def decode_msg(self, msg):
control_int = msg[0] * 1
fid = msg[1:9]
#msg = str(msg, "utf-8")
if (control_int == 0):
print("Sync Layer | New gossip received")
feed_len_int = msg[9] * 256 + msg[10]
self.handle_incoming_gossip(feed_len_int,fid)
elif (control_int == 1):
print("Sync Layer | New event received")
feed_len_int = msg[9] * 256 + msg[10]
data = msg[11:len(msg)]
self.handle_incoming_event(feed_len_int,data,fid)
def handle_incoming_gossip(self, msg,fid):
print("Sync Layer | Handle incoming gossip")
if (msg < self.feed_layer.get_feed_length(fid)):
print("Sync Layer | Sending event nr " + str(msg))
search = msg + 1
e_wired = self.feed_layer.get_wired_event(fid, search)
print("Sync Layer | Sending event: Length=" + str(len(e_wired)))
control_b = (1).to_bytes(1, 'big')
feed_len_b = search.to_bytes(2, 'big')
#wait random time before sending
random = int.from_bytes(os.urandom(1), "big")
gossip_waiting = self.gossip_wait + math.floor(random/256*5)
if self.verbose:
print('send_gossip waiting for '+ str(gossip_waiting))
time.sleep(gossip_waiting)
self.send_event(control_b + fid + feed_len_b + e_wired)
def handle_incoming_event(self, seq,msg,fid):
print("Sync Layer | Event data: " + str(msg))
#if (incoming_event[0] == len(self.events_list)): #check if already appended
#self.events_list.append(incoming_event)
#print("Acquired event:" + str(incoming_event[0]))
#fid = self.feed_layer.get_sensor_feed_fid()
self.feed_layer.append(fid,seq, msg)
print("Sync Layer | Feed length:" + str(self.feed_layer.get_feed_length(fid)))
#if data is needed automatically append data.
#else if it could be used later, store to a buffer.
#check if data usefull and append to feeds or append to buffer if event in between is missing
def send_event(self, msg):
self.link_layer.append_msg_to_pipeline(msg, False)
#events einzeln senden? Wie gross können einzelne Nachrichten sein?
def send_gossip(self):
while True:
# get current feeds
[pcap_list,fid_list] = self.feed_layer.get_fid_list()
random = int.from_bytes(os.urandom(1), "big")
gossip_waiting = self.gossip_wait + math.floor(random/256*5)
for fi in fid_list:
if self.verbose:
print('send_gossip waiting for '+ str(gossip_waiting))
time.sleep(gossip_waiting)
control_b = (0).to_bytes(1, 'big')
feed_len = self.feed_layer.get_feed_length(fi)
feed_len_b = feed_len.to_bytes(2, 'big')
gossip = control_b + fi + feed_len_b
if self.verbose:
[name,type] = self.feed_layer.get_name(fi)
print("Sync Layer | Send gossip: 0 " + name + " " + str(feed_len))
# control_b = (0).to_bytes(1, 'big')
# fid = self.feed_layer.get_sensor_feed_fid()
# feed_len = self.feed_layer.get_feed_length(fid)
# feed_len_b = feed_len.to_bytes(2, 'big')
#
# gossip = control_b + feed_len_b
#
# #a = str(gossip[0], 'big')
# #b = str(gossip[1:2], 'big')
# feed_len_int = feed_len_b[0] * 256 + feed_len_b[1]
# control_int = control_b[0] * 1
#print("Sync Layer | Feed lenght: " + str(len(self.feed)))
#msg = "gssp-bc//" + str(feed_len)
#print(msg)
self.link_layer.append_msg_to_pipeline(gossip, False)
class Gossip:
def __init__(self):
self.link_layer = Lora_Link_Layer(self.receive_msg_cb)
#self.events_list = ["1", "2", "3"]
self.events_list = [[0, "Hallo1"], [1, "Hallo2"], [2, "Hallo3"],
[3, "Hallo4"], [4, "Hallo3"], [5, "Hallo4"]]
#length = str(len(events_list))
self.incoming_data = []
self.incoming_ack = []
#learn rsii from incoming messages
_thread.start_new_thread(self.gssp_send_broadcast, ())
def receive_msg_cb(self, msg):
self.decode_msg(msg.decode('utf-8'))
def decode_msg(self, msg):
if (msg.startswith("gssp-bc")):
print("New Broadcast")
data = msg.split("//")[1]
self.gssp_handle_bc(data)
elif (msg.startswith("gssp-get")):
print("New Get")
data = msg.split("//")[1]
self.gssp_handle_get(data)
elif (msg.startswith("gssp-data")):
print("New Feed")
data = msg.split("//")[1]
self.gssp_handle_data(data)
elif (msg.startswith("gssp-ack")):
print("New ack")
data = msg.split("//")[1]
self.gssp_handle_ack(data)
def gssp_handle_bc(self, msg):
#start thread: -> send get (repeat) -> receive data (multiple) -> send ack (repeat)
print("Handle incoming_broadcast")
if (int(msg) > len(self.events_list)):
_thread.start_new_thread(self.thread_acquire_event,
(len(self.events_list), ))
def gssp_handle_get(self, msg):
#start thread: -> send data (repeat) -> receive ack (multiple?)
if (int(msg) < len(self.events_list)):
event = self.events_list[int(msg)]
self.gssp_send_feed(json.dumps(event))
#_thread.start_new_thread(self.thread_deliver_event, (int(msg),))
def gssp_handle_data(self, msg):
self.incoming_data.append(json.loads(msg))
print(self.incoming_data)
#check if data usefull and append to feeds
#check if data already received (but ack lost) and send ack again
def gssp_handle_ack(self, msg):
self.incoming_ack.append(int(msg))
def thread_acquire_event(self, event_nr):
acquiring_event = True
while acquiring_event:
self.gssp_send_get(event_nr)
print("Acquiring event:" + str(event_nr))
time.sleep(20)
for event in self.incoming_data:
print(str(event))
print(str(event_nr))
if (event[0] == event_nr): #check if already appended
if (len(self.events_list) == event_nr):
self.events_list.append(event)
self.gssp_send_ack(event_nr)
acquiring_event = False
print("Acquired event:" + str(event_nr))
else:
acquiring_event = False
print(str(self.events_list))
#send ack if data received -> delete data, keep meta
#if data is sent again, send ack again
#options start new thread or use the same
#what if ack gets lost? data is sent again! send ack again! keep in mind, which data received.
def thread_deliver_event(self, meta):
delivering_event = True
while delivering_event:
print("Delivering event")
event = self.events_list[meta]
self.gssp_send_feed(json.dumps(event))
time.sleep(20)
for ack in self.incoming_ack:
if (ack == event_nr):
delivering_event = False
print("Delivered event:" + str(event_nr))
def gssp_send_get(self, event_nr):
msg = "gssp-get//" + str(event_nr)
self.link_layer.append_msg_to_pipeline(msg, True)
def gssp_send_ack(self, event_nr):
msg = "gssp-ack//" + str(event_nr)
self.link_layer.append_msg_to_pipeline(msg, True)
def gssp_send_feed(self, msg):
msg = "gssp-data//" + str(msg)
self.link_layer.append_msg_to_pipeline(msg, True)
#events einzeln senden? Wie gross können einzelne Nachrichten sein?
def gssp_send_broadcast(self):
i = 0
while True:
random = int.from_bytes(os.urandom(1), "big")
gossip_waiting = 20 + math.floor(random / 256 * 5)
print(gossip_waiting)
time.sleep(gossip_waiting)
##feed_length = len(events_list)
msg = "gssp-bc//" + str(len(self.events_list))
print(msg)
#msg = msg.encode('utf-8')
i = i + 1
self.link_layer.append_msg_to_pipeline(msg, True)
