def compute_weight(self, node, key):
# a b values from research paper
a = 1103515245
b = 12345
node = int(hash_code_hex(str(node).encode()),
base=16) # Hashing both host & port
hash_val = int(hash_code_hex(key.encode()), base=16) # Hashing key
return (a * ((a * node + b) ^ hash_val) + b) % 4294967296 # 2^32
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):
object_bytes = pickle.dumps(self.servers[0])
hash_code = hash_code_hex(object_bytes)
highestWeight = self.hash_func(hash_code, self.servers[0]['port'])
highestNode = self.servers[0]
for server in self.servers:
obj_byte = pickle.dumps(server)
hc = hash_code_hex(obj_byte)
weight = self.hash_func(key, hc)
if weight > highestWeight:
highestWeight = weight
highestNode = server
#print("Candidate highest weight/node: " + str(highestWeight) + " , " + str(highestNode))
self.data[highestNode['port']].append("data")
self.data_count += 1
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 add(self, key):
for i in range(self.hash_count):
#index = mmh3.hash(key, i) % self.size
index = int(hash_code_hex(key.encode() + bytes(i)),
base=16) % self.size
#print(f"INDEX: {index}")
self.bit_array[index] = True
def weight(self, port, key):
a = 1103515245
b = 12345
key = key.strip()
hash = hash_code_hex(key.encode())
hex = int(hash, 16)
return (a * ((a * port + b) ^ hex) + b) % (2 ^ 31)
def get_machine(self, key):
h = int((int(hash_code_hex(key.encode()), 16) % 1000000) / 10000.0)
if h > self.hash_tuples[-1][2]:
return self.hash_tuples[0][0]
hash_values = map(lambda x: x[2], self.hash_tuples)
index = bisect.bisect_left(list(hash_values), h)
return self.hash_tuples[index][0]
def test():
ring = ConsistentHashNodeRing(NODES, 400, 3)
# print(len(ring.hash_ring))
# print(ring.hash_ring)
x = hash_code_hex('sdfsdf'.encode())
print(ring.get_nodes(x))
def create_server_keys(self):
temp = []
for server in self.servers:
object_bytes = pickle.dumps(server)
hash_code = hash_code_hex(object_bytes)
temp.append(hash_code)
return temp
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 is_member(self, key):
for i in range(self.hash_count):
#index = mmh3.hash(key, i) % self.size
index = int(hash_code_hex(key.encode() + bytes(i)),
base=16) % self.size
if self.bit_array[index] == False:
return False
return True
def add(self, item):
digests = []
for i in range(self.hash_count):
dump = pickle.dumps(item)
hash = hash_code_hex(dump)
index = int(hash, 16) % self.size
digests.append(index)
self.bit_array[index] = True
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 get_node(self, key_hex):
to_hash = key_hex.encode('utf-8')
key = int(hash_code_hex(to_hash), 16) % self.hashsize
pos = bisect.bisect(self._sorted_keys, key)
if(pos >= len(self._sorted_keys)-1):
pos = 0
nodeKey = self._sorted_keys[pos]
return self.ring[nodeKey]
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 is_member(self, item):
for i in range(self.hash_count):
dump = pickle.dumps(item)
hash = hash_code_hex(dump)
index = int(hash, 16) % self.size
if self.bit_array[index] == False:
return False
return True
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 compute_node_weight(node, key_hex):
a = 9876543210
b = 123456
node_string = str(node.host) + ":" + str(node.port)
object_bytes = pickle.dumps(node_string)
node_hash_hex = hash_code_hex(object_bytes)
key = int(key_hex, 16)
node_hash = int(node_hash_hex, 16)
return (a * ((a * node_hash + b) ^ key) + b) % (2 ^ 31)
def is_member(self, key):
global bf
size = len(bf)
for i in range(k):
val = hash_code_hex(key.encode('utf-8'))
index = int(val, 16) % size
if bf[index]:
return True
return False
def weight(self, node, key):
# a and b for calculating weight
a = 1103515245
b = 12345
# using existing hash function for hasing node and key both
hash_val = int(hash_code_hex(key.encode()), base=16)
return (a * ((a * node + b) ^ hash_val) + b) % (2 ^ 31)
def __init__(self, num_machines=1, v_nodes=1, replica_factor=1):
self.num_machines = num_machines
self.v_nodes = v_nodes
self.replica_factor = replica_factor
hash_tuples = [(j,k,int((int(hash_code_hex((str(j)+"_"+str(k)).encode()), 16) % 1000000) / 10000.0)) \
for j in range(self.num_machines) \
for k in range(self.v_nodes)]
hash_tuples.sort(key=lambda x: x[2])
self.hash_tuples = hash_tuples
def get_rendezvous_hash(self, key):
highScore, winner = -1, None
for i in range(len(self.nodes)):
score = self.get_score_rh(
key,
int(hash_code_hex(str(self.nodes[i].port).encode()), 16) %
5000, self.seeds_rh[i])
if score > highScore:
highScore, winner = score, self.nodes[i]
return winner
def get_node(self, key):
maximum_hash_value = None
maximum_node = None
for n in self.nodes:
temp_key = (str(n['port']) + key).encode('utf-8')
temporary_hash = int(hash_code_hex(temp_key), 16)
if maximum_hash_value is None or temporary_hash > maximum_hash_value:
maximum_hash_value = temporary_hash
maximum_node = n
return maximum_node
def get_node(self, key_hex):
max_hash_value = None
highest_node = None
for node in self.nodes:
to_hash = (str(node['port']) + key_hex).encode('utf-8')
temp_hash = int(hash_code_hex(to_hash), 16)
if max_hash_value is None or temp_hash > max_hash_value:
max_hash_value = temp_hash
highest_node = node
return highest_node
def add_nodes(self, nodes):
if nodes:
for node in nodes:
for i in range(self.replicas):
node_bytes = "%s_vnode%s" % (node, i)
node_bytes = bytes(node_bytes, encoding="utf8")
node_hash = hash_code_hex(node_bytes)
# node_hash = hashlib.md5(node_bytes).hexdigest()
self.ring[node_hash] = node
self._sorted_keys.append(node_hash)
self._sorted_keys.sort()
def add_virtual_nodes(self, total):
numOfVirtualNodesEach = int(self.totalNumOfVirtualNodes /
len(self.nodes))
for node in self.nodes:
currentKey = node
# create virtual nodes and map them to corresponding original nod
for i in range(numOfVirtualNodesEach):
nodeHash = hash_code_hex(str(currentKey).encode())
nodeIndex = int(nodeHash, 16) % self.m
self.hash_ring.append(nodeIndex)
self.virtual_to_original_mapping[str(nodeIndex)] = node
currentKey = nodeHash
def get_node(self, key_hex):
keyInRing = int(hash_code_hex(key_hex.encode()), 16) % self.max
# Bisect the Ring. If keyInRing value higher than n-1 point then return node 0.
# Hence map the node in clockwise direction.
d = 0
if self.ring[self.totalNodes - 1] > keyInRing:
d = bisect_right(self.ring, keyInRing)
print(self.lookup)
print(keyInRing)
return self.lookup[self.ring[d]]
def get_node(self, hash_key):
encoded_hash = hash_key.encode('utf-8')
key = int(hash_code_hex(encoded_hash), 16) % self.hash_size
position = bisect.bisect(self.sorted_keys, key)
if position >= len(self.sorted_keys) - 1:
position = 0
data_rep_position = position + 1
if data_rep_position >= len(self.sorted_keys) - 1:
data_rep_position = 0
node_key = self.sorted_keys[position]
rep_node_key = self.sorted_keys[data_rep_position]
return self.ring[node_key], self.ring[rep_node_key]
def get_node(self, key_hex):
hrw = 0
bestNode = None
for node in self.nodes:
# combines key and node with a delimeter (,) and converts it into a string for hashing
key_node_combo = key_hex + ',' + str(node)
weight_hex = hash_code_hex(key_node_combo.encode())
weight = int(weight_hex, 16)
if (weight > hrw):
hrw = weight
bestNode = node
return bestNode
def get_node(self, key):
key_bytes = bytes(key, encoding="utf8")
key_hash = hash_code_hex(key_bytes)
# keyhash=hashlib.md5(key_bytes).hexdigest()
index = 0
for node_hash in self._sorted_keys:
index += 1
if key_hash < node_hash:
return self.ring[node_hash]
else:
continue
if index == len(self._sorted_keys):
return self.ring[self._sorted_keys[0]]
