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!"