class Node(threading.Thread):
def __init__(self,
nodeID,
coordinates,
neighbor_dict,
q_obj,
dissipation_event,
transmission_event,
beginner=False):
threading.Thread.__init__(self)
self.nodeID = nodeID
self.coordinates = coordinates
self.neighbor_dict = neighbor_dict
self.beginner = beginner
self.q_obj = q_obj
self.dissipation_event = dissipation_event
self.transmission_event = transmission_event
self.queue = None
self.pend_on_queue_time = 480
self.packet_types = {1: 'INIT_ROUTE', 2: 'PATTERN', 3: 'DATA'}
self.packet_logger = LogRecord('packetlogger.txt')
self.sent_flag = 'SENT'
self.received_flag = 'RCVD'
def run(self):
logger.debug("Booted node: %s", str(self.nodeID))
self.q_list, self.neighbor_qname_list = self.create_neighbor_queues()
if self.beginner:
q = 'q_' + str(self.nodeID)
exec(q + " = self.q_obj.create_queue(" + "'" + str(q) + "'" + ")")
exec("self.queue = self.q_obj.get_from_repository(" + "'" + "q_" +
str(self.nodeID) + "'" + ")")
seed = self.create_random_seed()
init_route_packet = InitialRoutePacket(self.nodeID, seed)
qname_index = 0
for q in self.q_list:
deep_obj_copy = deepcopy(init_route_packet)
deep_obj_copy.packet_id = self.generate_uuid()
status = self.q_obj.put_to_queue(q, deep_obj_copy)
temp_node_name = self.neighbor_qname_list[qname_index].split(
'_')[1]
log_msg = self.packet_logger_message(deep_obj_copy.packet_id,
temp_node_name, 'SENT',
'INIT_ROUTE')
self.packet_logger.write_log(log_msg)
qname_index = qname_index + 1
else:
exec("self.queue = self.q_obj.get_from_repository(" + "'" + "q_" +
str(self.nodeID) + "'" + ")")
exec("q_size = self.q_obj.get_qsize (" + "'" + self.queue + "'" +
")")
q_counter = 0
for i in range(q_size):
exec("init_route_packet_" + str(self.nodeID) + "_" +
str(q_counter) + " = self.q_obj.get_from_queue (" +
repr(self.queue) + ")")
seed = self.create_random_seed()
exec("pkt_id = init_route_packet_" + str(self.nodeID) + "_" +
str(q_counter) + ".packet_id")
log_msg = self.packet_logger_message(pkt_id, "r", 'RCVD',
'INIT_ROUTE')
self.packet_logger.write_log(log_msg)
exec("disp_pkt = init_route_packet_" + str(self.nodeID) + "_" +
str(q_counter) + ".get_packet()")
exec("init_route_packet_" + str(self.nodeID) + "_" +
str(q_counter) + ".add_id_seed(self.nodeID, seed)")
deep_copy_dict_name = "deep_copy_dict_" + str(self.nodeID)
exec(deep_copy_dict_name + " = {}")
deep_copy_key = 0
for q in self.q_list:
#deep_obj_copy = deepcopy(init_route_packet)
exec(deep_copy_dict_name +
"[deep_copy_key] = deepcopy(init_route_packet_" +
str(self.nodeID) + "_" + str(q_counter) + ")")
exec(deep_copy_dict_name +
"[deep_copy_key].packet_id = self.generate_uuid()")
exec("pkt_id = " + deep_copy_dict_name +
"[deep_copy_key].packet_id")
exec("status = self.q_obj.put_to_queue(q," +
deep_copy_dict_name + "[deep_copy_key])")
temp_node_name = self.neighbor_qname_list[
deep_copy_key].split('_')[1]
log_msg = self.packet_logger_message(
pkt_id, temp_node_name, 'SENT', 'INIT_ROUTE')
self.packet_logger.write_log(log_msg)
deep_copy_key = deep_copy_key + 1
q_counter = q_counter + 1
self.dissipation_event.wait()
exec("q_size_for_pattern = self.q_obj.get_qsize (" + "'" + self.queue +
"'" + ")")
self.pattern_packet = self.q_obj.get_from_queue(self.queue)
pkt_id = self.pattern_packet.packet_id
log_msg = self.packet_logger_message(pkt_id, "r", 'RCVD', 'PATTERN')
self.packet_logger.write_log(log_msg)
if self.beginner:
self.dissipation_event.clear()
self.pattern = self.pattern_packet.get_this_pattern()
self.next_pattern = self.pattern_packet.get_next_pattern()
self.queue = self.q_obj.get_object_by_name(self.queue)
self.transmission_event.wait()
pkt_to_forward = self.pend_on_queue(self.queue,
self.pend_on_queue_time)
return
def pend_on_queue(self, q_, timeout, sleeptime=0):
retrieved_get = None
while (sleeptime < timeout):
time.sleep(0.1)
if q_.empty():
sleeptime = sleeptime + 1
timeout = timeout - 1
retrieved_get = self.pend_on_queue(q_, timeout, sleeptime)
return retrieved_get
else:
retrieved_get = q_.get_nowait()
pkt_to_forward = retrieved_get
if pkt_to_forward is not None:
if isinstance(pkt_to_forward, DataPacket):
if pkt_to_forward.packet_id:
pkt_id = pkt_to_forward.packet_id
else:
pkt_id = self.generate_uuid()
log_msg = self.packet_logger_message(
pkt_id, "r", 'RCVD', 'DATA')
self.packet_logger.write_log(log_msg)
if not pkt_to_forward.get_pattern():
pkt_to_forward.pattern.append(self.pattern)
if pkt_to_forward.get_pattern()[
len(pkt_to_forward.get_pattern()) -
1] == self.pattern:
forward_counter = 1
for q in self.q_list:
exec("deep_copy_" + str(forward_counter) +
" = deepcopy(pkt_to_forward) ")
exec("deep_copy_" + str(forward_counter) +
".pattern.append(self.next_pattern)")
exec("deep_copy_" + str(forward_counter) +
".packet_id= self.generate_uuid()")
exec("pkt_id = deep_copy_" +
str(forward_counter) + ".packet_id")
exec(
"status = self.q_obj.put_to_queue(q, deep_copy_"
+ str(forward_counter) + ")")
#get packet id and add packet sent debug
temp_node_name = str(
self.neighbor_qname_list[forward_counter -
1]).split('_')[1]
log_msg = self.packet_logger_message(
pkt_id, temp_node_name, 'SENT', 'DATA')
self.packet_logger.write_log(log_msg)
forward_counter = forward_counter + 1
retrieved_get = self.pend_on_queue(self.queue,
self.pend_on_queue_time)
return retrieved_get
def create_random_seed(self):
from random import randrange
return randrange(255)
def create_neighbor_queues(self):
qname_list = []
for neighbor in self.neighbor_dict[self.nodeID]:
qname = "q_" + str(neighbor)
qname_list.append(qname)
queue_object_list = []
for q in qname_list:
if self.q_obj.check_if_created(q):
exec(q + " = self.q_obj.get_object_by_name(" + "'" + str(q) +
"'" + ")")
else:
exec(q + " = self.q_obj.create_queue(" + "'" + str(q) + "'" +
")")
exec("queue_object_list.append(" + str(q) + ")")
return queue_object_list, qname_list
def packet_logger_message(self, pktid, to_, sent_or_received, pkt_type):
message = ""
if sent_or_received == self.sent_flag:
message = pktid + " " + pkt_type + " " + str(
self.nodeID) + " " + str(to_) + " " + sent_or_received + "\n"
elif sent_or_received == self.received_flag:
message = pktid + " " + pkt_type + " " + str(to_) + " " + str(
self.nodeID) + " " + sent_or_received + "\n"
return message
def generate_uuid(self):
str_uuid_full = str(uuid.uuid4()).split('-')
pkt_id = str_uuid_full[len(str_uuid_full) - 1]
return pkt_id
class Sink(threading.Thread):
def __init__(self, nodeID, coordinates, neighbor_dict, q_obj,
dissipation_event, transmission_event,
transmission_done_event):
threading.Thread.__init__(self)
self.nodeID = nodeID
self.coordinates = coordinates
self.neighbor_dict = neighbor_dict
self.q_obj = q_obj
self.dissipation_event = dissipation_event
self.transmission_event = transmission_event
self.transmission_done_event = transmission_done_event
self.sink_pattern = '51NK'
self.pend_on_queue_time = 600
self.packet_logger = LogRecord('packetlogger.txt')
self.sent_flag = 'SENT'
self.received_flag = 'RCVD'
def run(self):
init_sink_list = []
exec("pop_queue = self.q_obj.get_from_repository(" + "'" + "q_" +
str(self.nodeID) + "'" + ")")
exec("q_size = self.q_obj.get_qsize(" + "'" + str(pop_queue) + "'" +
")")
for i in range(q_size):
exec("init_route_packet = self.q_obj.get_from_queue(" + "'" +
str(pop_queue) + "'" + ")")
pkt_id = init_route_packet.packet_id
log_msg = self.packet_logger_message(pkt_id, "r", 'RCVD',
'INIT_ROUTE')
self.packet_logger.write_log(log_msg)
init_sink_list.append(init_route_packet)
self.all_routes_dict = self.condense_packets_store_seeds(
init_sink_list)
self.maps_to_route_id = self.map_nodes_to_route_id(
self.all_routes_dict, self.neighbor_dict)
self.routes_for_nodes = self.decide_routes_for_nodes(
self.maps_to_route_id, self.all_routes_dict)
self.final_path_list = self.get_full_paths(self.routes_for_nodes,
self.all_routes_dict)
self.create_and_store_pattern(self.final_path_list)
self.create_push_pattern_packets()
exec("self.queue = self.q_obj.get_from_repository(" + "'" + "q_" +
str(self.nodeID) + "'" + ")")
self.queue = self.q_obj.get_object_by_name(self.queue)
self.transmission_event.wait()
pkt_to_forward = self.pend_on_queue(self.queue,
self.pend_on_queue_time)
return
def pend_on_queue(self, q_, timeout, sleeptime=0):
retrieved_get = None
while (sleeptime < timeout):
time.sleep(0.1)
if q_.empty():
sleeptime = sleeptime + 1
timeout = timeout - 1
print "Queue Empty. Pending again"
retrieved_get = self.pend_on_queue(q_, timeout, sleeptime)
else:
retrieved_get = q_.get_nowait()
logging.debug("%s: Received packet from the queue",
str(self.nodeID))
if isinstance(retrieved_get, DataPacket):
if (retrieved_get.get_pattern()
[len(retrieved_get.get_pattern()) -
1] == self.sink_pattern):
packet_data = retrieved_get.get_data()
packet_sender = retrieved_get.get_pattern()[0]
pkt_id = retrieved_get.packet_id
log_msg = self.packet_logger_message(
pkt_id, packet_sender, 'RCVD', 'DATA')
self.packet_logger.write_log(log_msg)
retrieved_get = self.pend_on_queue(
q_, timeout, self.pend_on_queue_time)
return retrieved_get
def condense_packets_store_seeds(self, full_pkt_list):
self.seed_dict = {}
return_dict = {}
condensed_list = []
for item in full_pkt_list:
condensed_list_item = []
for node_x in item.get_packet():
self.seed_dict.update({node_x[0]: node_x[1]})
condensed_list_item.append(node_x[0])
condensed_list.append(condensed_list_item)
route_id = 1
for item in condensed_list:
return_dict.update({route_id: item})
route_id = route_id + 1
return return_dict
def map_nodes_to_route_id(self, initial_packet_dict, neighbor_dict):
all_nodes = neighbor_dict.keys()
visited_nodes = []
every_node_to_sink = []
node_and_route_id = {}
for node_x in all_nodes:
rid_length_dict = {}
for route in initial_packet_dict.items():
update_value = {}
if node_x in route[1]:
inx = route[1].index(node_x)
rid_length_dict.update({route[0]: len(route[1][inx:])})
min_path = min(rid_length_dict.values())
for route in rid_length_dict.items():
if route[1] == min_path:
update_value = {node_x: route[0]}
break
node_and_route_id.update(update_value)
return node_and_route_id
def decide_routes_for_nodes(self, node_to_route_dict, ini_dict):
self.final_list = []
for value in node_to_route_dict.items():
exec("route_" + str(value[1]) + " = []")
temp_iter_list = list(set(node_to_route_dict.values()))
for route_ in temp_iter_list:
for val in node_to_route_dict.items():
if route_ == val[1]:
exec("route_" + str(val[1]) + ".append(" + str(val[0]) +
")")
exec("self.final_list.append(route_" + str(route_) + ")")
return self.final_list
def get_full_paths(self, ntor_list, ini_dict):
route_ = 1
final_path_list = []
for item in ntor_list:
for node_x in item:
for n in ini_dict[route_]:
if node_x == n:
path_tmp = ini_dict[route_][ini_dict[route_].index(n):]
final_path_list.append(path_tmp)
break
route_ = route_ + 1
break
return final_path_list
def create_and_store_pattern(self, final_path_list):
import random
import string
self.path_pattern_dict = {}
self.next_node_dict = {}
for seed_item in self.seed_dict.items():
alpha = random.choice(string.letters)
new_seed = str(seed_item[1]) + alpha
self.seed_dict.update({seed_item[0]: new_seed})
node_pattern = ''
self.seed_dict.update({self.nodeID: self.sink_pattern})
for path in final_path_list:
for node_ in path:
node_pattern = node_pattern + str(self.seed_dict[node_])
self.path_pattern_dict.update({node_pattern: node_})
try:
self.next_node_dict.update(
{node_: path[path.index(node_) + 1]})
except IndexError:
self.next_node_dict.update({node_: self.nodeID})
return
def create_push_pattern_packets(self):
from PatternPacket import PatternPacket
self.q_rep = self.q_obj.get_q_repository()
for node_ in self.next_node_dict:
#if node id is beginner, delay sending the pattern packets. When node 1 receives the pattern, clear the dissipation event
#creating pattern packets
exec("pkt_" + str(node_) + " = PatternPacket (" + "'" +
str(self.seed_dict[node_]) + "'" + ", " + "'" +
str(self.seed_dict[self.next_node_dict[node_]]) + "'" + ")")
exec("pkt_" + str(node_) + ".packet_id = self.generate_uuid()")
#pushing pattern packets to queues
qname = 'q_' + str(node_)
if qname in self.q_rep.keys():
queue_obj = self.q_rep[qname]
exec("pkt_id = pkt_" + str(node_) + ".packet_id")
exec("status = self.q_obj.put_to_queue( queue_obj " + ", " +
"pkt_" + str(node_) + ")")
log_msg = self.packet_logger_message(pkt_id, str(node_),
'SENT', 'PATTERN')
self.packet_logger.write_log(log_msg)
self.dissipation_event.set()
return
def packet_logger_message(self, pktid, to_, sent_or_received, pkt_type):
message = ""
if sent_or_received == self.sent_flag:
message = pktid + " " + pkt_type + " " + str(
self.nodeID) + " " + str(to_) + " " + sent_or_received + "\n"
elif sent_or_received == self.received_flag:
message = pktid + " " + pkt_type + " " + str(to_) + " " + str(
self.nodeID) + " " + sent_or_received + "\n"
return message
def generate_uuid(self):
import uuid
str_uuid_full = str(uuid.uuid4()).split('-')
pkt_id = str_uuid_full[len(str_uuid_full) - 1]
return pkt_id
