def put(self, key, value, address): """ Store value in DHT. Parameters: key: key of the data value: data to be stored address: address where to send ack/nack """ key_hash = dht_hash(key) self.logger.debug('Put: %s %s', key, key_hash) # my responsability if contains_successor(self.id, self.successor_id, key_hash): self.keystore[key] = value self.send(address, {'method': 'ACK'}) else: # send to DHT dest_addr = self.finger_table.closest_preceding_node(key_hash) self.send( dest_addr, { 'method': 'PUT', 'args': { 'key': key, 'value': value, 'client_address': address } })
def put(self, key, value, address): """ Store value in DHT. Parameters: key: key of the data value: data to be stored address: address where to send ack/nack """ key_hash = dht_hash(key) self.logger.debug('Put: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): self.keystore[key] = value self.send(address, {'method': 'ACK'}) else: # send to DHT # Remote search implementation start msg = { 'method': 'PUT', 'args': { 'key': key, 'value': value, 'clientAddr': address } } self.send(self.FT_closest_preceding_node(key_hash), msg) print(f"# It is {self.FT_closest_preceding_node(key_hash)}")
def node_join(self, args): """ Process JOIN_REQ message. add entries to the Table while a node is joining Parameters: args (dict): addr and id of the node trying to join """ self.logger.debug('Node join: %s', args) addr = args['addr'] identification = args['id'] successor_id, successor_addr = self.fingerTable.getFirstEntry() if self.id == successor_id: #I'm the only node in the DHT successor_id = identification successor_addr = addr self.fingerTable.set_succ(successor_id, successor_addr) args = {'successor_id': self.id, 'successor_addr': self.addr} self.send(addr, {'method': 'JOIN_REP', 'args': args}) elif contains_successor(self.id, successor_id, identification): args = { 'successor_id': successor_id, 'successor_addr': successor_addr } successor_id = identification successor_addr = addr self.fingerTable.set_succ(successor_id, successor_addr) self.send(addr, {'method': 'JOIN_REP', 'args': args}) else: self.logger.debug('Find Successor(%d)', args['id']) self.send(successor_addr, {'method': 'JOIN_REQ', 'args': args}) self.logger.info(self)
def put(self, key, value, address, src_address=None): key_hash = dht_hash(key) self.logger.debug('Put: %s %s', key, key_hash) self.logger.debug('%s < %s < %s', self.id, key_hash, self.successor_id) # if self.id < key_hash <= self.successor_id or self.successor_id < self.id <= key_hash: if contains_successor(self.id, self.successor_id, key_hash): self.keystore[key] = value if src_address != None: self.logger.debug("Sending to %s", src_address) self.send(src_address, { 'method': 'ACK', 'args': { 'value': value } }) else: self.logger.debug("Sending to %s", address) self.send(address, {'method': 'ACK', 'args': {'value': value}}) else: # send to DHT if src_address == None: src_address = address self.send( self.get_finger_table(key_hash), { 'method': 'PUT', 'args': { 'key': key, 'src_address': src_address, 'value': value } })
def node_join(self, args): """ Process JOIN_REQ message. Parameters: args (dict): addr and id of the node trying to join """ self.logger.debug('Node join: %s', args) addr = args['addr'] identification = args['id'] if self.id == self.successor_id: #I'm the only node in the DHT self.successor_id = identification self.successor_addr = addr args = {'successor_id': self.id, 'successor_addr': self.addr} self.send(addr, {'method': 'JOIN_REP', 'args': args}) elif contains_successor(self.id, self.successor_id, identification): args = { 'successor_id': self.successor_id, 'successor_addr': self.successor_addr } self.successor_id = identification self.successor_addr = addr self.send(addr, {'method': 'JOIN_REP', 'args': args}) else: self.logger.debug('Find Successor(%d)', args['id']) self.send(self.successor_addr, { 'method': 'JOIN_REQ', 'args': args }) self.logger.info(self)
def node_join(self, args): self.logger.debug('Node join: %s', args) addr = args['addr'] identification = args['id'] self.logger.error('ID: %s; SUCC: %s', self.id, self.successor_id) if self.id == self.successor_id: # Se ele for o seu proprio Sucessor, aceita logo o primeiro candidato self.successor_id = identification self.successor_addr = addr args = {'successor_id': self.id, 'successor_addr': self.addr} self.send(addr, {'method': 'JOIN_REP', 'args': args}) elif contains_successor( self.id, self.successor_id, identification ): # Se já tiver Sucessor, verifica se este é um melhor candidato (tem um ID menor que o sucessor atual)... args = { 'successor_id': self.successor_id, 'successor_addr': self.successor_addr } #...em caso afirmativo, responde com informaçao relativa ao (ex) sucessor self.successor_id = identification self.successor_addr = addr self.send(addr, {'method': 'JOIN_REP', 'args': args}) else: self.logger.debug( 'Find Successor(%d)', args['id'] ) # Se o candidato não puder ser o novo Sucessor, o Node propraga a informação para o próximo self.send(self.successor_addr, { 'method': 'NODE_JOIN', 'args': args }) self.logger.info(self)
def entity_join(self, args): self.logger.debug('Entity join: %s', args) port = args['port'] identification = args['id'] if self.id == self.succ_ID: self.succ_ID = identification self.succ_port = port args = {'succ_ID': self.id, 'succ_PORT': self.port} self.send(port, {'method': 'NODE_JOIN_REP', 'args': args}) elif contains_successor(self.id, self.succ_ID, identification): args = { 'succ_ID': self.succ_ID, 'succ_PORT': self.succ_port, } self.succ_ID = identification self.succ_port = port self.send(port, {'method': 'NODE_JOIN_REP', 'args': args}) else: self.logger.debug('Find Successor(%d)', args['id']) self.send(self.succ_port, { 'method': 'NODE_JOIN_REQ', 'args': args })
def stabilize(self, x, addr): self.logger.debug('Stabilize: %s %s', x, addr) if x is not None and contains_successor(self.id, self.successor_id, x): self.successor_id = x self.successor_addr = addr args = {'predecessor_id': self.id, 'predecessor_addr': self.addr} self.send(self.successor_addr, {'method': 'NOTIFY', 'args': args})
def stabilize(self, from_id, addr): """ Process STABILIZE protocol. Updates all successor pointers. Parameters: from_id: id of the predecessor of node with address addr addr: address of the node sending stabilize message """ self.logger.debug('Stabilize: %s %s', from_id, addr) if from_id is not None and contains_successor( self.id, self.successor_id, from_id): # Update our successor self.successor_id = from_id self.successor_addr = addr # update finger table index = self.finger_table.get_update_index() hash_id = (self.id + 2**(index - 1)) % 1024 dest_addr = self.finger_table.closest_preceding_node(hash_id) self.send( dest_addr, { 'method': 'FIND_SUCC', 'args': { 'hash_id': hash_id, 'index': index, 'origin_addr': self.addr } }) # notify successor of our existence, so it can update its predecessor record args = {'predecessor_id': self.id, 'predecessor_addr': self.addr} self.send(self.successor_addr, {'method': 'NOTIFY', 'args': args})
def node_join(self, args): self.logger.debug('Node join: %s', args) addr = args['addr'] identification = args['id'] if identification is not None and addr is not None: self.add_finger(identification, addr) if self.id == self.successor_id: self.successor_id = identification self.successor_addr = addr args = {'successor_id': self.id, 'successor_addr': self.addr} self.send(addr, {'method': 'JOIN_REP', 'args': args}) elif contains_successor(self.id, self.successor_id, identification): args = { 'successor_id': self.successor_id, 'successor_addr': self.successor_addr } self.successor_id = identification self.successor_addr = addr self.send(addr, {'method': 'JOIN_REP', 'args': args}) else: self.logger.debug('Find Successor(%d)', args['id']) self.send(self.successor_addr, { 'method': 'JOIN_REQ', 'args': args }) self.logger.info(self)
def get(self, key, address): key_hash = dht_hash(key) self.logger.debug('Get: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): value = self.keystore[key] self.send(address, {'method': 'ACK', 'args': value}) else: self.send(self.successor_addr, {'method': 'GET', 'args': { 'key': key, 'address': address}})
def put(self, key, value, address): key_hash = dht_hash(key) self.logger.debug('Put: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): self.keystore[key] = value self.send(address, {'method': 'ACK'}) else: self.send(self.successor_addr, {'method': 'PUT', 'args': { 'key': key, 'value': value, 'address': address}})
def put(self, key, value, address): key_hash = dht_hash(key) self.logger.debug('Put: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): self.keystore[key] = value self.send(address, {'method': 'ACK'}) else: #Add to the message the src_addr of the "example.py" msg = {'method': 'PUT', 'args':{'key':key, 'value': value, 'src_addr': address}} self.send(self.successor_addr, msg)
def get(self, key, address): key_hash = dht_hash(key) self.logger.debug('Get: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): value = self.keystore[key] self.send(address, {'method': 'ACK', 'args': value}) else: # send to DHT # Fill here self.send(address, {'method': 'NACK'})
def put(self, key, value, address): key_hash = dht_hash(key) self.logger.debug('Put: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): self.keystore[key] = value self.send(address, {'method': 'ACK'}) else: # send to DHT # Fill here self.send(address, {'method': 'NACK'})
def stabilize(self, from_id, addr): """ Process STABILIZE protocol. Updates all successor pointers. Parameters: from_id: id of the predecessor of node with address addr addr: address of the node sending stabilize message """ self.logger.debug('Stabilize: %s %s', from_id, addr) successor_id, successor_addr = self.fingerTable.getFirstEntry() if from_id is not None and contains_successor(self.id, successor_id, from_id): # Update our successor successor_id = from_id successor_addr = addr self.fingerTable.set_succ(successor_id, successor_addr) # notify successor of our existence, so it can update its predecessor record args = {'predecessor_id': self.id, 'predecessor_addr': self.addr} self.send(successor_addr, {'method': 'NOTIFY', 'args': args})
def find_successor(self, hash_id, index, origin_addr): if contains_successor(self.id, self.successor_id, hash_id): self.send(origin_addr, { 'method': 'UPDATE', 'args': { 'index': index } }) else: # send to DHT dest_addr = self.finger_table.closest_preceding_node(hash_id) self.send( dest_addr, { 'method': 'FIND_SUCC', 'args': { 'hash_id': hash_id, 'index': index, 'origin_addr': origin_addr } })
def put(self, key, value, client_addr): """ Store value in DHT. Parameters: key: key of the data value: data to be stored address: address where to send ack/nack """ successor_id, successor_addr = self.fingerTable.getFirstEntry() key_hash = int(key) if value != None: key_hash = dht_hash(key) self.logger.debug("ID: %s SUCCESSOR ID: %s Key Hash: %s", (self.id), (successor_id), (key_hash)) if contains_successor(self.id, successor_id, key_hash): if value == None: msg = { 'method': 'ACK_FT', 'args': { 'id': successor_id, 'addr': successor_addr } } self.logger.debug("Sending ACK_FT %s TO %s", msg, client_addr) self.send(client_addr, msg) else: self.keystore[key] = value self.send(client_addr, {'method': 'ACK'}) else: next_id, next_addr = self.fingerTable.finger_get(key_hash) msg = { 'method': 'PUT', 'args': { 'key': key, 'value': value, 'client_addr': client_addr } } self.send(next_addr, msg) self.logger.debug(self.fingerTable.lst)
def get(self, key, address, src_address=None): key_hash = dht_hash(key) self.logger.debug('Get: %s %s', key, key_hash) # if self.id < key_hash <= self.successor_id or self.successor_id < self.id <= key_hash: if contains_successor(self.id, self.successor_id, key_hash): value = self.keystore[key] if src_address != None: self.send(src_address, {'method': 'ACK', 'args': value}) else: self.send(address, {'method': 'ACK', 'args': value}) else: # send to DHT if src_address == None: src_address = address self.send(self.get_finger_table(key_hash), { 'method': 'GET', 'args': { 'key': key, 'src_address': src_address } })
def entity_join(self, args): identification = args['id'] address = args['address'] self.logger.info('NODE_JOIN - Request from ID: %s; Address: %s;', identification, address) if self.id == self.successor_id: self.successor_id = identification self.successor_addr = address args = {'successor_id': self.id, 'successor_addr': self.address} self.logger.info('NODE_JOIN - Successor: %s; Address: %s', self.successor_id, self.successor_addr) self.send(address,{'method': 'NODE_JOIN_REP', 'args': args}) elif contains_successor(self.id, self.successor_id, identification): args = {'successor_id': self.successor_id, 'successor_addr': self.successor_addr} self.successor_id = identification self.successor_addr = address self.logger.info('NODE_JOIN - Successor: %s; Address: %s', self.successor_id, self.successor_addr) self.send(address, {'method': 'NODE_JOIN_REP', 'args': args}) else: self.logger.debug('NODE_JOIN - Find Successor (id = %s)', identification) self.send(self.successor_addr, {'method': 'NODE_JOIN_REQ', 'args': args})
def get(self, key, address): """ Retrieve value from DHT. Parameters: key: key of the data address: address where to send ack/nack """ key_hash = dht_hash(key) self.logger.debug('Get: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): value = self.keystore[key] self.send(address, {'method': 'ACK', 'args': value}) else: # send to DHT dest_addr = self.finger_table.closest_preceding_node(key_hash) self.send(dest_addr, { 'method': 'GET', 'args': { 'key': key, 'client_address': address } })
def stabilize(self, from_id, addr): """ Process STABILIZE protocol. Updates all successor pointers. Parameters: from_id: id of the predecessor of node with address addr addr: address of the node sending stabilize message """ self.logger.debug('Stabilize: %s %s', from_id, addr) if from_id is not None and contains_successor( self.id, self.successor_id, from_id): # Update our successor self.successor_id = from_id self.successor_addr = addr # notify successor of our existence, so it can update its predecessor record args = {'predecessor_id': self.id, 'predecessor_addr': self.addr} self.send(self.successor_addr, {'method': 'NOTIFY', 'args': args}) # <DHT> self.fingerTable[0].key = self.predecessor_id self.fingerTable[0].nodeid = self.predecessor_id self.fingerTable[0].address = self.predecessor_addr for i in range(1, 11): #range(1,11) = 1, 2, ..., 10 succid, succaddr = self.FT_getSuccessor(self.fingerTable[i].key, self.id, self.addr) if succid and succaddr: self.fingerTable[i].nodeid = succid self.fingerTable[i].address = succaddr # Give feedback self.logger.debug('Updated fingerTable...') for ind in self.fingerTable: self.logger.debug('\t%s', ind) # Save finger table to file with open("ft/" + self.id.__str__() + ".txt", "w") as f: for ind in self.fingerTable: f.write(f"{ind}\n")
def get(self, key, address): """ Retrieve value from DHT. Parameters: key: key of the data address: address where to send ack/nack """ key_hash = dht_hash(key) self.logger.debug('Get: %s %s', key, key_hash) if contains_successor(self.id, self.successor_id, key_hash): value = self.keystore[key] self.send(address, {'method': 'ACK', 'args': value}) else: # send to DHT # Remote search implementation start msg = { 'method': 'GET', 'args': { 'key': key, 'clientAddr': address } } self.send(self.successor_addr, msg)
def node_join(self, args): self.logger.debug('Node join: %s', args) addr = args['addr'] identification = args['id'] if self.id == list(self.finger_table.keys())[0]: self.finger_table[identification] = addr args = {'successor_id': self.id, 'successor_addr': self.addr} self.send(addr, {'method': 'JOIN_REP', 'args': args}) elif contains_successor(self.id, self.successor_id, identification): args = { 'successor_id': self.successor_id, 'successor_addr': self.successor_addr } self.successor_id = identification self.successor_addr = addr self.finger_table[identification] = add else: self.send(addr, {'method': 'JOIN_REP', 'args': args}) self.logger.debug('Find Successor(%d)', args['id']) self.send(self.successor_addr, { 'method': 'JOIN_REQ', 'args': args }) self.logger.info(self)
def get(self, key, client_addr): """ Retrieve value from DHT. Parameters: key: key of the data address: address where to send ack/nack """ key_hash = dht_hash(key) self.logger.debug('Get: %s %s', key, key_hash) successor_id, successor_addr = self.fingerTable.getFirstEntry() if contains_successor(self.id, successor_id, key_hash): value = self.keystore[key] self.send(client_addr, {'method': 'ACK', 'args': value}) else: # send to DHT next_id, next_addr = self.fingerTable.finger_get(key_hash) msg = { 'method': 'GET', 'args': { 'key': key, 'client_addr': client_addr } } self.send(next_addr, msg)