def process(udp_clients):
ring = NodeRing(nodes=NODES)
hash_codes = set()
# PUT all users.
for u in USERS:
data_bytes, key = serialize_PUT(u)
# TODO: PART II - Instead of going to server 0, use Naive hashing to split data into multiple servers
#fix_me_server_id = 0
fix_me_server_id = NODES.index(ring.get_node(key))
print(f"Server id: {fix_me_server_id}")
response = udp_clients[fix_me_server_id].send(data_bytes)
hash_codes.add(response)
print(response)
print(
f"Number of Users={len(USERS)}\nNumber of Users Cached={len(hash_codes)}"
)
# TODO: PART I
# GET all users.
for hc in hash_codes:
print(f"GET:{hc}")
data_bytes, key = serialize_GET(hc)
fix_me_server_id = NODES.index(ring.get_node(key))
response = udp_clients[fix_me_server_id].send(data_bytes)
#print(deserialize(response))
print(response)
# DELETE all users
for hc in hash_codes:
# print(hc)
data_bytes, key = serialize_DELETE(hc)
fix_me_server_id = NODES.index(ring.get_node(key))
response = udp_clients[fix_me_server_id].send(data_bytes)
print(response)
def process(udp_clients):
ch_ring = ChNodeRing(NODES)
hash_codes = set()
# PUT all users.
for u in USERS:
data_bytes, key = serialize_PUT(u)
server = ch_ring.get_node(key)
ch_server_id = NODES.index(ast.literal_eval(
server)) #ast.literal to convert string output to dict element
response = udp_clients[ch_server_id].send(data_bytes)
hash_codes.add(response)
print(response)
print(
f"Number of Users={len(USERS)}\nNumber of Users Cached={len(hash_codes)}"
)
# GET all users.
for hc in hash_codes:
data_bytes, key = serialize_GET(hc)
key = key.decode("utf-8")
server = ch_ring.get_node(key)
ch_server_id = NODES.index(ast.literal_eval(server))
response = udp_clients[ch_server_id].send(data_bytes)
#print(deserialize(response))
print(response)
# DELETE all users
for hc in hash_codes:
data_bytes, key = serialize_DELETE(hc)
key = key.decode("utf-8")
server = ch_ring.get_node(key)
ch_server_id = NODES.index(ast.literal_eval(server))
response = udp_clients[ch_server_id].send(data_bytes)
print(response)
def process(udp_clients):
rhw_ring = RhwNodeRing(NODES)
hash_codes = set()
# PUT all users.
for u in USERS:
data_bytes, key = serialize_PUT(u)
server = rhw_ring.get_node(key)
rhw_server_id = NODES.index(server)
response = udp_clients[rhw_server_id].send(data_bytes)
hash_codes.add(response)
print(response)
print(
f"Number of Users={len(USERS)}\nNumber of Users Cached={len(hash_codes)}"
)
# GET all users.
for hc in hash_codes:
data_bytes, key = serialize_GET(hc)
key = key.decode("utf-8")
server = rhw_ring.get_node(key)
rhw_server_id = NODES.index(server)
response = udp_clients[rhw_server_id].send(data_bytes)
#print(deserialize(response))
print(response)
# DELETE all users
for hc in hash_codes:
data_bytes, key = serialize_DELETE(hc)
key = key.decode("utf-8")
server = rhw_ring.get_node(key)
rhw_server_id = NODES.index(server)
response = udp_clients[rhw_server_id].send(data_bytes)
print(response)
def process(udp_clients):
hash_codes = set()
# PUT all users.
for u in USERS:
data_bytes, key = serialize_PUT(u)
ring = NodeRing(NODES)
server_index = NODES.index(ring.get_node(key))
response = udp_clients[server_index].put(key, data_bytes)
hash_codes.add(response.decode())
print(response)
print(
f"Number of Users={len(USERS)}\nNumber of Users Cached={len(hash_codes)}"
)
# GET all users.
for hc in hash_codes:
print(hc)
data_bytes, key = serialize_GET(hc)
ring = NodeRing(NODES)
server_index = NODES.index(ring.get_node(key))
response = udp_clients[server_index].get_request(hc, data_bytes)
print(response)
# Delete all Users
for hc in hash_codes:
print(hc)
data_bytes, key = serialize_DELETE(hc)
ring = NodeRing(NODES)
server_index = NODES.index(ring.get_node(key))
response = udp_clients[server_index].delete(key, data_bytes)
print(response)
def put(self, udp_clients, key, data_bytes):
# PUT all users.
ring = NodeRing(NODES)
fix_me_server_id = NODES.index(ring.get_node(key))
response = udp_clients[fix_me_server_id].send(data_bytes)
hash_codes.add(response)
print(f"Server--->Number of Users Cached={len(hash_codes)}")
return "hi"
def getAll(self, udp_clients):
for hc in hash_codes:
data_bytes, key = serialize_GET(hc)
ring = NodeRing(NODES)
fix_me_server_id = NODES.index(ring.get_node(key))
print(data_bytes)
response = udp_clients[fix_me_server_id].send(data_bytes)
print(f"Server GETALL--->{response}")
return response
def put(key, val):
print("ADD KEY to BLOOM FILTER")
bloom_f.add(key)
print("PUT to SERVER:")
fix_me_server_id = NODES.index(ring.get_node(key))
print(f"Server id: {fix_me_server_id}")
response = clients[fix_me_server_id].send(val)
hash_codes.add(response)
#print(response)
return response
def process(udp_clients):
ch_ring = ChNodeRing(NODES)
hash_codes = set()
# PUT all users.
for u in USERS:
data_bytes, key = serialize_PUT(u)
server1, server2, server3 = ch_ring.get_node_with_replication(key)
# 3 server ids for data replication on next 2 nodes of the main node at hash node ring
ch_server_id_1 = NODES.index(ast.literal_eval(
server1)) #ast.literal to convert string output to dict element
ch_server_id_2 = NODES.index(ast.literal_eval(server2))
ch_server_id_3 = NODES.index(ast.literal_eval(server3))
response_1 = udp_clients[ch_server_id_1].send(data_bytes)
response_2 = udp_clients[ch_server_id_2].send(data_bytes)
response_3 = udp_clients[ch_server_id_3].send(data_bytes)
hash_codes.add(response_1)
hash_codes.add(response_2)
hash_codes.add(response_3)
print(response_1, response_2, response_3)
print(
f"Number of Users={len(USERS)}\nNumber of Users Cached={len(hash_codes)}"
)
# GET all users.
for hc in hash_codes:
data_bytes, key = serialize_GET(hc)
key = key.decode("utf-8")
server = ch_ring.get_node(key)
ch_server_id = NODES.index(ast.literal_eval(server))
response = udp_clients[ch_server_id].send(data_bytes)
#print(deserialize(response))
print(response)
# DELETE all users
for hc in hash_codes:
data_bytes, key = serialize_DELETE(hc)
key = key.decode("utf-8")
server = ch_ring.get_node(key)
ch_server_id = NODES.index(ast.literal_eval(server))
response = udp_clients[ch_server_id].send(data_bytes)
print(response)
def delete(key):
if (bloom_f.is_member(key)):
print(f"DELETE on SERVER:")
data_bytes, key_ser = serialize_DELETE(key.encode())
fix_me_server_id = NODES.index(ring.get_node(key_ser))
response = clients[fix_me_server_id].send(data_bytes)
#print(response)
return response
else:
print("### KEY FOR DELETE NOT FOUND IN BLOOM FILTER ###")
return None
def get(self, udp_clients, key):
k = key.encode()
for hc in hash_codes:
if (hc == k):
data_bytes, key = serialize_GET(hc)
ring = NodeRing(NODES)
fix_me_server_id = NODES.index(ring.get_node(key))
response = udp_clients[fix_me_server_id].send(data_bytes)
print(f"Server GET--->{response}")
return response
return None
def rendezvous_hashing(self, key):
max_weight = 0
node_index = 0
for i in NODES:
data_bytes, node_key = serialize_PUT(i)
weight = (int(key, 16) + int(node_key, 16)) % len(
NODES) #compute weight for each node
if weight > max_weight:
max_weight = weight
node_index = NODES.index(i)
print("Selected node is ", node_index)
return node_index
def get(key):
if (bloom_f.is_member(key)):
data_bytes, key_ser = serialize_GET(key.encode())
print(f"*** GET from SERVER: ***")
fix_me_server_id = NODES.index(ring.get_node(key_ser))
response = clients[fix_me_server_id].send(data_bytes)
# print(deserialize(response))
#print(response)
return response
else:
print("### KEY FOR GET NOT FOUND IN BLOOM FILTER ###")
return None
def delete(self, udp_clients, key):
k = key.encode()
for hc in hash_codes:
print(hash_codes)
if (hc == k):
data_bytes, key = serialize_DELETE(hc)
ring = NodeRing(NODES)
fix_me_server_id = NODES.index(ring.get_node(key))
response = udp_clients[fix_me_server_id].send(data_bytes)
hash_codes.remove(hc)
#print(hash_codes)
break
print(f"Server DELETE--->Number of Users Cached={len(hash_codes)}")