def forward_response_data(file_bytes, request_id, node_ip, status, path):
curr_path = eval(path)
curr_coordinates = curr_path.pop()
#check if data reached the initial invoking node
if curr_path.empty():
return file_bytes
#get the channel through which the data will be propogated
for item in globals.node_connections.connection_dict.items():
if item[1].node_coordinates == curr_coordinates:
channel = item[1].channel
break
#check if channel is alive. if not, update the 2D matrix and calculate a new shortest path
if not channel.isAlive():
mesh = create_logical_mesh()
mesh[curr_coordinates[0]][curr_coordinates[1]] = 0
curr_path = find_shortest_path(mesh)
forward_response_data(file_bytes, request_id, node_ip, status,
curr_path)
#forward the request
traversal_stub = traversal_pb2_grpc.TraversalStub(channel)
response = traversal_stub.RespondData(
traversal_pb2.RespondDataRequest(file_bytes=file_bytes,
request_id=request_id,
node_ip=node_ip,
status=status,
path=curr_path))
return response
def send_request():
time.sleep(10)
server_node_ip = "10.0.0.3"
logger.info("Connecting to {} at port {}...".format(server_node_ip, globals.port))
traversal_stub = traversal_pb2_grpc.TraversalStub(globals.node_connections.connection_dict[NodePosition.RIGHT].channel)
logger.debug(traversal_stub)
response = traversal_stub.ReceiveData(
traversal_pb2.ReceiveDataRequest(
hash_id="hashid",
request_id="1",
stack=str([]),
visited=str([])))
logger.info("forward_receive_data_request: response: {}".format(response))
def send_request():
# time.sleep(60)
server_node_ip = "10.0.0.1"
logger.info("Connecting to {} at port {}...".format(
server_node_ip, globals.port))
channel = grpc.insecure_channel(server_node_ip + ":" + str(globals.port))
traversal_stub = traversal_pb2_grpc.TraversalStub(channel)
logger.debug(traversal_stub)
response = traversal_stub.ReceiveData(
traversal_pb2.ReceiveDataRequest(hash_id="hashid",
request_id="1",
stack=str([]),
visited=str([])))
logger.info("forward_receive_data_request: response: {}".format(response))
def forward_receive_data_request(node_ip, request):
logger.info("forward_receive_data_request: node_ip: {}".format(node_ip))
channel = None
for item in globals.node_connections.connection_dict.items():
if item[1].node_ip == node_ip:
channel = item[1].channel
break
traversal_stub = traversal_pb2_grpc.TraversalStub(channel)
response = traversal_stub.ReceiveData(hash_id=request.hash_id,
request_id=request.request_id,
stack=request.stack,
visited=request.visited)
logger.info("forward_receive_data_request: response: {}".format(response))
return response
def forward_receive_data_request(self, node_ip, channel, request,
visited_ip, requesting_node_ip):
logger.info(
"forward_receive_data_request: node_ip: {}".format(node_ip))
traversal_stub = traversal_pb2_grpc.TraversalStub(channel)
response = traversal_stub.ReceiveData(
traversal_pb2.ReceiveDataRequest(
hash_id=str(request.hash_id),
request_id=str(request.request_id),
stack="",
visited=str(visited_ip),
requesting_node_ip=requesting_node_ip))
logger.info(
"forward_receive_data_request: response: {}".format(response))
return response
def ReceiveData(self, request, context):
logger.info(
"Traversal.ReceiveData hash_id:{} request_id:{} visited:{}".format(
request.hash_id, request.request_id, request.visited))
# print("Traversal.ReceiveData hash_id:{} request_id:{} visited:{}"
# .format(request.hash_id, request.request_id, request.visited))
print("came hereeeeeee")
data_found = globals.storage_object.is_hash_id_in_memory_non_rpc(
request.hash_id)
# Check if the file exits on current node
if data_found:
channel = grpc.insecure_channel(request.requesting_node_ip + ":" +
str(globals.port))
traversal_stub = traversal_pb2_grpc.TraversalStub(channel)
chunks_list = globals.storage_object.download_list_of_data_chunks_non_rpc(
request.hash_id)
logger.debug("SendData: chunk: {}".format(chunks_list))
for c in chunks_list:
yield traversal_stub.SendData(
traversal_pb2.SendDataRequest(
file_bytes=c,
request_id=request.request_id,
client_node_ip=globals.my_ip))
# curr_data = fetch_data(request.hash_id)
# curr_mesh = self.create_logical_mesh()
# curr_path = self.find_shortest_path(curr_mesh)
# self.forward_response_data(curr_data, request.request_id, "", traversal_pb2.ReceiveDataResponse.TraversalResponseStatus.FOUND,
# curr_path)
# # RespondData(file_bytes=curr_data, request_id=request.request_id, node_ip = request.node_ip, status = traversal_response_status.FOUND, path = curr_path)
# return traversal_pb2.ReceiveDataResponse(status=traversal_pb2.ReceiveDataResponse.TraversalResponseStatus.FOUND)
# If file not found in node
visited_ip = eval(request.visited)
globals.data_received_event.clear()
if globals.my_ip not in visited_ip:
visited_ip.append(globals.my_ip)
logger.info("Traversal.ReceiveData: visited: {}".format(visited_ip))
neighbor_conn_list = []
for item in globals.node_connections.connection_dict.items():
neighbor_conn_list.append(item[1])
forward_conn_list = []
for neighbor_conn in neighbor_conn_list:
logger.debug("visited_ip: {}".format(visited_ip))
if neighbor_conn.node_ip not in visited_ip:
logger.debug(
"Adding {} in visited_ip and forward_conn_list".format(
neighbor_conn.node_ip))
visited_ip.append(neighbor_conn.node_ip)
forward_conn_list.append(neighbor_conn)
print("Forwarded List: {}".format(
[conn.node_ip for conn in forward_conn_list]))
print("Neighbor List: {}".format(
[conn.node_ip for conn in neighbor_conn_list]))
print("Visited List: {}".format(visited_ip))
logger.info("Forwarded List: {}".format(
[conn.node_ip for conn in forward_conn_list]))
logger.info("Neighbor List: {}".format(
[conn.node_ip for conn in neighbor_conn_list]))
logger.info("Visited List: {}".format(visited_ip))
threading_list = []
for forward_conn in forward_conn_list:
forward_node_ip = forward_conn.node_ip #confirm
channel = forward_conn.channel #confirm
logger.debug("Forwarded Node IP: {}".format(forward_node_ip))
# print("Channel: {}".format(channel))
forward_request_thread = threading.Thread(
target=self.forward_receive_data_request,
args=(forward_node_ip, channel, request, visited_ip,
request.requesting_node_ip))
threading_list.append(forward_request_thread)
for thread in threading_list:
thread.start()
#thread.join()
while not globals.data_received_event.is_set():
# wait for data
time.sleep(0.1)
# return traversal_pb2.ReceiveDataResponse(
# status=traversal_pb2.ReceiveDataResponse.TraversalResponseStatus.FORWARDED) # confirm indentation
logger.debug("Response: {}".format(globals.data_received))
logger.debug("Return")
#for chunk in globals.data_received:
logger.debug("ReceiveDataRespnse: chunk: {}".format(
globals.data_received))
for c in globals.data_received:
yield traversal_pb2.ReceiveDataResponse(
status=traversal_pb2.ReceiveDataResponse.
TraversalResponseStatus.FOUND,
file_bytes=c)