def __init__(self, address, dht_address=None, timeout=3):
""" Constructor
Parameters:
address: self's address
dht_address: address of a node in the DHT
timeout: impacts how often stabilize algorithm is carried out
"""
threading.Thread.__init__(self)
self.id = dht_hash(address.__str__())
self.addr = address #My address
self.dht_address = dht_address #Address of the initial Node
if dht_address is None:
self.inside_dht = True
#I'm my own successor
self.successor_id = self.id
self.successor_addr = address
self.predecessor_id = None
self.predecessor_addr = None
else:
self.inside_dht = False
self.successor_id = None
self.successor_addr = None
self.predecessor_id = None
self.predecessor_addr = None
self.keystore = {} # Where all data is stored
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.settimeout(timeout)
self.logger = logging.getLogger("Node {}".format(self.id))
self.finger_table = FingerTable(self.successor_addr)
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 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 closest_preceding_node(self, node_id):
# ainda nao tem em conta os ids serem circulares
print(self.ft)
for entry in self.ft[::-1]:
if entry and dht_hash(entry.__str__()) < node_id:
print(entry)
return entry
def __init__(self, address, dht_address=None, timeout=5, dht_size=1024, m=4):
threading.Thread.__init__(self)
self.finger_table = [(None, None, None)] * m
self.id = dht_hash(address.__str__())
self.addr = address
self.dht_address = dht_address
if dht_address is None:
self.successor_id = self.id
self.successor_addr = address
self.predecessor_id = None
self.predecessor_addr = None
self.inside_dht = True
else:
self.inside_dht = False
self.successor_id = None
self.successor_addr = None
self.predecessor_id = None
self.predecessor_addr = None
self.finger_table[0] = (self.successor_id, None, self.successor_addr)
for i in range(1, m):
self.finger_table[i] = (
(self.id+(dht_size/(m*2)*i)) % 1024, None, None)
self.keystore = {}
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.settimeout(timeout)
self.logger = logging.getLogger("Node {}".format(self.id))
def put(self, key, value, address):
key_hash = dht_hash(key)
self.logger.debug('Put: %s %s', key, key_hash)
# message to send to another node
msg = {
'method': 'PUT',
'args': {
'key': key,
'value': value,
'client_addr': address
}
}
if self.id < key_hash <= self.successor_id:
self.keystore[key] = value
self.send(address, {'method': 'ACK'})
elif self.successor_id < self.id:
if self.id < key_hash <= 1024:
self.keystore[key] = value
self.send(address, {'method': 'ACK'})
elif self.successor_id < key_hash:
self.send(self.successor_addr, msg)
elif key_hash <= self.id:
self.send(self.predecessor_addr, msg)
else:
self.send(address, {'method': 'NACK'})
def __init__(self, address, dht_address=None, timeout=3):
threading.Thread.__init__(self)
self.id = dht_hash(address.__str__())
self.addr = address
self.dht_address = dht_address
# finger table dictionary
self.finger_table = {}
# method: 'FINGER' ttl - 9
# method: 'FINGER' -> volta ao anel
if dht_address is None:
# put successor node in the FT
self.finger_update(self.id, address)
self.predecessor_id = None
self.predecessor_addr = None
self.inside_dht = True
else:
self.inside_dht = False
self.successor_id = None
self.successor_addr = None
self.predecessor_id = None
self.predecessor_addr = None
self.keystore = {}
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.settimeout(timeout)
self.logger = logging.getLogger("Node {}".format(self.id))
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 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 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)
#TODO Replace next code:
self.send(address, {"method": "NACK"})
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)
#TODO Replace next code:
self.send(address, {"method": "NACK"})
def get(self, key, address):
key_hash = dht_hash(key)
self.logger.debug('Get: %s %s', key, key_hash)
msg = {'method': 'GET', 'args': {'key': key, 'client_addr': address}}
if self.id < key_hash <= self.successor_id:
value = self.keystore[key]
self.send(address, {'method': 'ACK', 'args': value})
elif self.successor_id < self.id:
if self.id < key_hash <= 1024:
value = self.keystore[key]
self.send(address, {'method': 'ACK', 'args': value})
elif self.successor_id < key_hash:
self.send(self.successor_addr, msg)
elif key_hash <= self.id:
self.send(self.predecessor_addr, msg)
else:
self.send(address, {'method': 'NACK'})
def get(self, key, address):
key_hash = dht_hash(key)
self.logger.debug('Get: %s %s', key, key_hash)
succ_addr = finger_get(key_hash)
if succ_addr == -1:
self.send(address, {'method': 'NACK'})
elif succ_addr == 0:
value = self.keystore[key]
self.send(address, {'method': 'ACK', 'args': value})
else:
self.send(succ_addr, {
'method': 'GET',
'args': {
'key': key,
'client_addr': address
}
})
def __init__(self, address, dht_address=None, timeout=3):
""" Constructor
--- Arguments
address: self's address
dht_address: address of a node in the DHT
timeout: impacts how often stabilize algorithm is carried out
"""
print("Initializing...")
threading.Thread.__init__(self)
self.id = dht_hash(address.__str__())
self.addr = address #My address
self.dht_address = dht_address #Address of the initial Node
if dht_address is None:
self.inside_dht = True
#I'm my own successor
self.successor_id = self.id
self.successor_addr = address
self.predecessor_id = None
self.predecessor_addr = None
else:
self.inside_dht = False
self.successor_id = None
self.successor_addr = None
self.predecessor_id = None
self.predecessor_addr = None
self.keystore = {} # Where all data is stored
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.settimeout(timeout)
self.logger = logging.getLogger("Node {}".format(self.id))
# <DHT>
self.fingerTable = []
self.fingerTable.append(
DHT_Index(self.predecessor_id, self.predecessor_id,
self.predecessor_addr))
for i in range(1, 11):
self.fingerTable.append(DHT_Index(self.id + 2**(i - 1)))
self.logger.debug('Initialized fingerTable...')
for ind in self.fingerTable:
self.logger.debug('\t%s', ind)
def put(self, key, value, address):
key_hash = dht_hash(key)
self.logger.debug('Put: %s %s', key, key_hash)
succ_addr = self.finger_get(key_hash)
if succ_addr == -1:
self.send(address, {'method': 'NACK'})
elif succ_addr == 0:
self.keystore[key] = value
self.send(address, {'method': 'ACK'})
else:
self.send(
succ_addr, {
'method': 'PUT',
'args': {
'key': key,
'value': value,
'client_addr': address
}
})
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 __init__(self, address, dht_address=None, timeout=3):
threading.Thread.__init__(self)
self.id = dht_hash(address.__str__())
self.addr = address
self.dht_address = dht_address
if dht_address is None:
self.successor_id = self.id
self.successor_addr = address
self.predecessor_id = None
self.predecessor_addr = None
self.inside_dht = True
else:
self.inside_dht = False
self.successor_id = None
self.successor_addr = None
self.predecessor_id = None
self.predecessor_addr = None
self.keystore = {}
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.settimeout(timeout)
self.logger = logging.getLogger("Node {}".format(self.id))
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 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 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 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)
