def delete(self, key):
print("H this is key from delete operation:", key)
if key in self.keys():
del self[key]
return serialize({"Message": "Delete Successful"})
else:
return serialize({"Message": "No such file"})
def add(self, key):
data = serialize(key)
for hash in range(self.num0fHashes):
location = hash_code_hex(data)
data = serialize(location)
location = int(location, 16) % self.array_size
self.bitArray[location] = 1
def get(self, key):
# print("hello")
# print("this is key:", key)
if key in self.keys():
return serialize(self[key])
else:
return serialize({"ErrorMessage": "No such file"})
def is_member(self, key):
data = serialize(key)
for hash in range(self.num0fHashes):
location = hash_code_hex(data)
data = serialize(location)
location = int(location, 16) % self.array_size
if self.bitArray[location] == 0:
return False
return True
def del_node(self,node):
node_bytes = serialize(node)
node_bytes = str(hash_code_hex(node_bytes))
listOfVirtualNodes = self.get_virtual_nodes(node_bytes)
for vnode in listOfVirtualNodes:
name_bytes = serialize(vnode)
node_hash = str(hash_code_hex(name_bytes))
node_hash = int(node_hash,16) % self.numOfKeys
self.node_location.remove(node_hash)
del self.nodes[node_hash]
del self.node_count[node_hash]
def get_node(self, key):
list_weights = []
for node in self.nodes:
node_addrdress = str(node.host + ":" + str(node.port))
new_key = key + node_addrdress
new_key_bytes = serialize(new_key)
node_hash = hash_code_hex(new_key_bytes)
node_hash = int(node_hash, 16)
list_weights.append((node_hash, node))
_, node = max(list_weights)
return node
# Nodes = []
# for i in range(5):
# Nodes.append(f"Node{str(i)}")
#
# hrw = HRWHashing(Nodes)
# hrw.add_node("Node6")
# hrw.del_node(Nodes[0])
# index = 0
# for j in range(50):
# answer = hrw.get_node(str(j))
# if answer =="Node5":
# index = index+1
# print(index)
def add_node(self, node):
node_bytes = serialize(node)
node_bytes = str(hash_code_hex(node_bytes))
# creating the virtual nodes for each node , params : node details and number of virtual nodes to be made
listOfVirtualNodes = self.get_virtual_nodes(node_bytes)
for vnode in listOfVirtualNodes:
name_bytes = serialize(vnode)
node_hash = str(hash_code_hex(name_bytes))
node_hash = int(node_hash,16) % self.numOfKeys
if node_hash in self.node_location:
raise Exception("Node Already Exists")
else:
self.nodes[node_hash] = node
bisect.insort(self.node_location,node_hash)
# print("New Node added at location : ",node_hash)
self.node_count[node_hash] = list()
def put(user, client_ring):
userBytes = serialize(user)
userHashcode = hash_code_hex(userBytes)
bloomfilter.add(userHashcode)
data_bytes, key = serialize_PUT(user)
response = client_ring.get_node(key).send(data_bytes)
return response
def handle_operation(self, operation, key, value):
if operation == 'GET':
# TODO: PART I - implement GET retrieval from self.db.xxxxx
id = key.decode()
output = self.db[id]
return serialize(output)
elif operation == 'PUT':
return self.db.put(key, value)
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def handle_operation(self, operation, key, value):
if operation == 'GET':
# return serialize(self.db.get(key.decode()))
return serialize(self.db.get(key))
elif operation == 'PUT':
return self.db.put(key, value)
elif operation == 'DELETE':
return self.db.delete(key)
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def handle_operation(self, operation, key, value):
if operation == 'GET':
temp_data = self.db.get(key)
yolo = serialize(temp_data)
return yolo
elif operation == 'PUT':
return self.db.put(key, value)
elif operation == 'DELETE':
return self.db.delete(key)
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def handle_operation(self, operation, key, value):
if operation == 'GET':
# TODO: PART I - implement GET retrieval from self.db.xxxxx
obj = self.db.get(key)
# convert dict to bytes
envelope_bytes = serialize(obj)
return envelope_bytes
# return 'FIX_ME'.encode()
elif operation == 'PUT':
return self.db.put(key, value)
elif operation == 'DELETE':
# try:
if self.db.get(key) != None:
del self.db[key]
envelope_bytes = serialize('success')
# except Exception e:
# print(e)
return envelope_bytes
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def handle_operation(self, operation, key, value):
if operation == 'GET':
ss = str(key.decode("utf-8"))
# TODO: PART I - implement GET retrieval from self.db.xxxxx
return (serialize(self.db[ss]))
elif operation == 'PUT':
return self.db.put(key, value)
elif operation == 'DELETE':
return self.db.delete(key)
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def get_node(self, key_hex):
hashVal=0
node_index=0
for i in range(len(self.nodes)):
obj ={}
obj['host']=self.nodes[i]['host']
obj['port']=self.nodes[i]['port']
obj['key']=key_hex
nodekey=int(hash_code_hex(serialize(obj)),16)
if nodekey>hashVal:
hashVal=nodekey
node_index=i
return self.nodes[node_index]
def put(user, client_ring):
userBytes = serialize(user)
userHashcode = hash_code_hex(userBytes)
bloomfilter.add(userHashcode)
data_bytes, key = serialize_PUT(user)
# sends PUT request to multiple nodes for data replication
nodesToSendTo = client_ring.get_nodes(key)
responses = []
for node in nodesToSendTo:
response = node.send(data_bytes)
print(response)
responses.append(response)
return responses
def handle_operation(self, operation, key, value):
if operation == 'GET':
# TODO: PART I - implement GET retrieval from self.db.xxxxx
#return 'FIX_ME'.encode()
return serialize(self.db.get(key))
elif operation == 'PUT':
return self.db.put(key, value)
elif operation == 'DELETE':
return self.db.delete(key)
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def run(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((self.host, self.port))
while True:
data, ip = s.recvfrom(BUFFER_SIZE)
print("{}:size={}".format(ip, len(data)))
response = self.extract_request(data)
# reply back to the client
if isinstance(response, str):
response = response.encode()
if isinstance(response, dict):
response = serialize(response)
s.sendto(response, ip)
def lru_test_put(local_size, function, object):
cache_size = int(local_size)
name = function.__name__
key = serialize(object)
key_hash = hash_code_hex(key)
if not hash_map.__contains__(key_hash):
val = function(object)
node = Node(key_hash, val)
id_to_node[key_hash] = node
dllist.update_node(node)
print(f"{name}({object}) -> {node.data}")
return val
else:
node = id_to_node[key_hash]
print(
f"cache hit, cache size is {cache_size} : {name}({object}) -> {node.data}"
)
return node.data
def __init__(self, nodes, mode='Default', replicas=2):
assert len(nodes) > 0
self.nodes = nodes
self.mode = mode
if self.mode == 'Rendezvous Hashing':
for i in range(len(nodes)):
self.seeds_rh.append(i)
elif self.mode == 'Consistent Hashing':
self.replicas_ch = replicas
# multiply the server nodes by the replication factor to get vnodes
for node in self.nodes:
for i in range(self.replicas_ch):
self.nodes_ch.append((node, i))
for vnode in self.nodes_ch:
hashedID = hash_code_hex(serialize(vnode))
self.hashedNodeList.append(hashedID)
self.vnodeMapping[hashedID] = vnode[0]
self.hashedNodeList.sort()
print(f'operation={operation}\nid={key}\npayload={payload}')
response = self.handle_operation(operation, key, payload)
return response
def handle_operation(self, operation, key, value):
if operation == 'GET':
<<<<<<< HEAD
# part 1: if key exist return content, otherwise return cache miss warning
key = key.decode()
content = self.db.get(key, None)
if content is None:
return 'CACHE_MISS'.encode()
return serialize(self.db.get(key))
=======
return self.db.get(key)
>>>>>>> 556104674fc8fc44f8d4aa3feb2744770a1166d4
elif operation == 'PUT':
print(key)
return self.db.put(key, value)
else:
print(f'Error: Invalid operation={operation}')
return 'Not supported operation={}'.format(operation)
def run(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((self.host, self.port))
def get(self, key):
value = "Key does not exist."
if key in self:
value = self[key]
return serialize(value)
def get(self, key):
decoded_key = key
try:
return serialize(self[decoded_key])
except KeyError:
return "data deleted!"
