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)
