def test_exchange_views(self): p1 = PartialView("First IP", 4, 3) p1.add_peer(PodDescriptor("172.0.1.6", 0)) p1.add_peer(PodDescriptor("172.0.1.3", 2)) p1.add_peer(PodDescriptor("172.0.1.5", 3)) p1.add_peer(PodDescriptor("Second IP", 5)) p2 = PartialView("Second IP", 4, 3) p2.add_peer(PodDescriptor("172.0.1.3", 0)) p2.add_peer(PodDescriptor("172.0.1.5", 1)) p2.add_peer(PodDescriptor("172.0.1.2", 2)) p2.add_peer(PodDescriptor("172.0.1.1", 4)) ######################## # P1 starts the exchange ######################## # 1) Increase by one the age of all neighbors p1.increment() # 2) Select neighbor Q with the highest age among all neighbors. oldest = p1.get_oldest_peer() # 3) Select l - 1 other random neighbors (meaning avoid oldest). request = p1.select_neighbors_for_request(oldest) # 4) Replace Q's entry with a new entry of age 0 and with P's address. request.add_peer_ip(p1.ip, allow_self_ip=True) self.assertTrue(request.is_full()) self.assertEqual(request.size, p1.shuffle_length) ################################################ # P2 receives neighbors and prepares a reply ################################################ reply = p2.select_neighbors_for_reply() self.assertTrue(request.is_full()) self.assertEqual(request.size, p1.shuffle_length) # Note that in p1 the oldest is p2 # p1 and p2 know two peers in common # p2 does not have an entry with p1's ip # p1.merge should: # - Discard 172.0.1.3 and 172.0.1.5 # - Put in unknown list 172.0.1.2, 172.0.1.1 # 6) I remove the oldest peer from my view p1.remove_peer(oldest) p1.merge(request, reply) self.assertTrue(p1.is_full()) for peer in reply.get_peer_list(): self.assertTrue(p1.contains(peer)) self.assertLessEqual(self.partialView.size, self.partialView.limit)
def test_add_peer_with_allow_self_should_allow_self_entry(self): ip = "my ip" p1 = PartialView(ip) peer = PodDescriptor(ip) size = self.partialView.size success = p1.add_peer(peer, True) self.assertTrue(success) self.assertTrue(p1.contains_ip(ip)) self.assertEqual(p1.size, size + 1)
class TestPartialView(unittest.TestCase): @classmethod def setUpClass(cls): pass def setUp(self): self.partialView = PartialView("172.0.1.0") self.descriptors = [] self.ips = [ "172.0.1.1", "172.0.1.2", "172.0.1.3", "172.0.1.4", "172.0.1.5" ] for ip in self.ips: self.descriptors.append(PodDescriptor(ip)) # Limit should be equal to VIEW_LIMIT and shuffle_length should be equal to SHUFFLE_LENGTH def test_set_up_ok(self): self.assertEqual(self.partialView.limit, int(os.environ['VIEW_LIMIT'])) self.assertEqual(self.partialView.shuffle_length, int(os.environ['SHUFFLE_LENGTH'])) # Initial partialView should be empty def test_initial_partial_view_empty(self): self.assertEqual(self.partialView.size, 0) self.assertTrue(self.partialView.is_empty()) # Method is_full should return false if partial view is not full def test_initial_partial_view_should_not_be_full(self): self.assertFalse(self.partialView.is_full()) # Method is_full should return true if partial view is full def test_is_full_should_return_true_if_full(self): for i in range(self.partialView.limit): self.partialView.add_peer(self.descriptors[i]) self.assertTrue(self.partialView.is_full()) self.assertEqual(self.partialView.size, self.partialView.limit) # Method add_peer should return false if peer already contained def test_add_peer_should_return_false_if_peer_already_contained(self): peer = PodDescriptor("A new IP") self.partialView.add_peer(peer) size = self.partialView.size duplicated = PodDescriptor("A new IP") success = self.partialView.add_peer(duplicated) self.assertFalse(success) self.assertEqual(self.partialView.size, size) self.assertEqual(self.partialView.size, len(self.partialView.peer_list)) # Method add_peer should not allow to insert a self entry def test_add_peer_should_not_allow_self_entry(self): ip = "my ip" p1 = PartialView(ip) peer = PodDescriptor(ip) size = self.partialView.size success = p1.add_peer(peer) self.assertFalse(success) self.assertFalse(p1.contains_ip(ip)) self.assertEqual(p1.size, size) # Method add_peer should allow to insert a self entry if forced def test_add_peer_with_allow_self_should_allow_self_entry(self): ip = "my ip" p1 = PartialView(ip) peer = PodDescriptor(ip) size = self.partialView.size success = p1.add_peer(peer, True) self.assertTrue(success) self.assertTrue(p1.contains_ip(ip)) self.assertEqual(p1.size, size + 1) # Method add_peer should increment size if view is not full def test_add_peer_should_increment_size_if_not_full(self): size = self.partialView.size peer = PodDescriptor("A new IP") self.partialView.add_peer(peer) self.assertTrue(self.partialView.contains(peer)) self.assertEqual(self.partialView.size, size + 1) self.assertEqual(self.partialView.size, len(self.partialView.peer_list)) # Method add_peer should not increment size if view is full def test_add_peer_should_not_increment_size_if_full(self): peer = PodDescriptor("A new IP") for i in range(self.partialView.limit): self.partialView.add_peer(self.descriptors[i]) size = self.partialView.size success = self.partialView.add_peer(peer) self.assertFalse(success) self.assertFalse(self.partialView.contains(peer)) self.assertEqual(self.partialView.size, size) self.assertEqual(self.partialView.size, len(self.partialView.peer_list)) # Method add_peer_ip should return false if peer already contained def test_add_peer_ip_should_return_false_if_peer_already_contained(self): peer = "A new IP" self.partialView.add_peer_ip(peer) size = self.partialView.size duplicated = "A new IP" success = self.partialView.add_peer_ip(duplicated) self.assertFalse(success) self.assertEqual(self.partialView.size, size) self.assertEqual(self.partialView.size, len(self.partialView.peer_list)) # Method add_peer_ip should not allow to insert a self entry def test_add_peer_ip_should_not_allow_self_entry(self): ip = "my ip" p1 = PartialView(ip) size = self.partialView.size success = p1.add_peer_ip(ip) self.assertFalse(success) self.assertFalse(p1.contains_ip(ip)) self.assertEqual(p1.size, size) # Method add_peer_ip should allow to insert a self entry if forced def test_add_peer_ip_with_allow_self_should_allow_self_entry(self): ip = "my ip" p1 = PartialView(ip) size = self.partialView.size success = p1.add_peer_ip(ip, True) self.assertTrue(success) self.assertTrue(p1.contains_ip(ip)) self.assertEqual(p1.size, size + 1) # Method add_peer_ip should increment size if view is not full def test_add_peer_ip_should_increment_size_if_not_full(self): size = self.partialView.size peer = "A new IP" self.partialView.add_peer_ip(peer) self.assertTrue(self.partialView.contains_ip(peer)) self.assertEqual(self.partialView.size, size + 1) self.assertEqual(self.partialView.size, len(self.partialView.peer_list)) # Method add_peer_ip should not increment size if view is full def test_add_peer_ip_should_not_increment_size_if_full(self): peer = "A new IP" for i in range(self.partialView.limit): self.partialView.add_peer(self.descriptors[i]) size = self.partialView.size success = self.partialView.add_peer_ip(peer) self.assertFalse(success) self.assertFalse(self.partialView.contains_ip(peer)) self.assertEqual(self.partialView.size, size) self.assertEqual(self.partialView.size, len(self.partialView.peer_list)) # Initial age should be zero def test_initial_age_peer(self): self.partialView.add_peer(PodDescriptor("172.0.1.5")) self.assertEqual(self.partialView.peer_list[0].age, 0) # Initial age should be zero def test_initial_age_peer_ip(self): self.partialView.add_peer_ip("172.0.1.5") self.assertEqual(self.partialView.peer_list[0].age, 0) # Method get_peer_ip_list should return a list of ips def test_get_peer_ip_list_returns_ips(self): for ip in self.ips: self.partialView.add_peer_ip(ip) self.assertEqual(self.partialView.get_peer_ip_list(), self.ips[:self.partialView.limit]) # Initial age should be zero def test_partial_view_size_limit(self): for ip in self.ips: self.partialView.add_peer_ip(ip) self.assertEqual(self.partialView.size, self.partialView.limit) self.assertTrue(self.partialView.is_full()) for i in range(self.partialView.limit): self.assertEqual(self.partialView.peer_list[i].ip, self.ips[i]) def test_contains_return_true_if_contained(self): for descr in self.descriptors: self.partialView.add_peer(descr) for descr in self.descriptors[:self.partialView.size]: self.assertTrue(self.partialView.contains(descr)) for descr in self.descriptors[self.partialView.size:]: self.assertFalse(self.partialView.contains(descr)) def test_contains_ip_return_true_if_contained(self): for ip in self.ips: self.partialView.add_peer_ip(ip) for ip in self.ips[:self.partialView.size]: self.assertTrue(self.partialView.contains_ip(ip)) for ip in self.ips[self.partialView.size:]: self.assertFalse(self.partialView.contains_ip(ip)) # Age should be incremented by one def test_increment(self): self.partialView.add_peer(PodDescriptor("172.0.1.5", 1)) self.partialView.add_peer(PodDescriptor("172.0.1.7", 3)) self.partialView.increment() self.assertEqual(self.partialView.peer_list[0].age, 2) self.assertEqual(self.partialView.peer_list[1].age, 4) # Sort should sort view by peer's age def test_sort(self): self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) self.partialView.add_peer(PodDescriptor("172.0.1.8", 1)) self.partialView.sort() self.assertEqual(self.partialView.peer_list[0].ip, "172.0.1.8") self.assertEqual(self.partialView.peer_list[1].ip, "172.0.1.5") self.assertEqual(self.partialView.peer_list[2].ip, "172.0.1.4") # Method sample_descriptors should return an empty list if view is empty def test_sample_descriptors_should_return_empty_list_if_empty_view(self): sample = self.partialView.sample_descriptors(3) self.assertEqual(len(sample), 0) self.assertEqual(sample, []) self.assertTrue(isinstance(sample, list)) # Method sample_descriptors should return a list of size element if the view's size is less than the limit given as parameter def test_sample_descriptors_should_return_less_than_limit_peers_if_size_less_than_limit( self): self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) size = self.partialView.size sample = self.partialView.sample_descriptors(3) self.assertEqual(len(sample), size) # Method sample_descriptors should return a list of limit peers despite the size of the the view is greater then limit def test_sample_descriptors_should_return_no_more_than_limit_peers(self): self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) self.partialView.add_peer(PodDescriptor("172.0.1.9", 4)) limit = 2 size = self.partialView.size sample = self.partialView.sample_descriptors(limit) self.assertNotEqual(limit, size) self.assertEqual(len(sample), limit) # Method sample_descriptors should return a list of 1 peer and avoid the peer given as parameter def test_sample_descriptors_with_avoid_peer_more_than_limit(self): to_avoid = PodDescriptor("172.0.1.9", 4) self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) self.partialView.add_peer(to_avoid) limit = 1 sample = self.partialView.sample_descriptors(limit, to_avoid) self.assertEqual(len(sample), limit) self.assertFalse(to_avoid in sample) # Method sample_descriptors should return a list of 2 peers and avoid the peer given as parameter def test_sample_descriptors_with_avoid_peer_less_than_limit(self): to_avoid = PodDescriptor("172.0.1.9", 4) self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) self.partialView.add_peer(to_avoid) limit = 3 sample = self.partialView.sample_descriptors(limit, to_avoid) self.assertEqual(len(sample), 2) self.assertFalse(to_avoid in sample) # Method sample_descriptors should return a list of 3 peers if the peer to avoid is not contained in the view def test_sample_descriptors_with_avoid_peer_not_in_view(self): to_avoid = PodDescriptor("172.0.1.9", 4) self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) self.partialView.add_peer(PodDescriptor("172.0.1.10", 8)) limit = 3 sample = self.partialView.sample_descriptors(limit, to_avoid) self.assertEqual(len(sample), limit) self.assertFalse(to_avoid in sample) # Method sample_ips should return a list of 3 ips def test_sample_ips_should_return_a_list_of_ips(self): self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) self.partialView.add_peer(PodDescriptor("172.0.1.10", 8)) limit = 3 sample = self.partialView.sample_ips(limit) self.assertIn("172.0.1.5", sample) self.assertIn("172.0.1.4", sample) self.assertIn("172.0.1.10", sample) # Method sample_ips should return a list of 3 ips loadable by epto # def test_sample_ips_should_return_a_list_of_ips_loadable_by_epto(self): # self.partialView.add_peer(PodDescriptor("172.0.1.5", 2)) # self.partialView.add_peer(PodDescriptor("172.0.1.4", 3)) # self.partialView.add_peer(PodDescriptor("172.0.1.10", 8)) # sample = json.dumps(self.partialView.sample_ips(2)) # # EpTO's code when EpTO invokes get_k_view() # view = [ip.encode('ascii', 'ignore') for ip in json.loads(sample)] # for destination in view: # self.assertIsInstance(destination, str) # self.assertIn(destination, self.partialView.get_peer_ip_list()) # Test the exchange of views. # P1 plays the role of P while P2 plays the role of Q described in comments def test_exchange_views(self): p1 = PartialView("First IP", 4, 3) p1.add_peer(PodDescriptor("172.0.1.6", 0)) p1.add_peer(PodDescriptor("172.0.1.3", 2)) p1.add_peer(PodDescriptor("172.0.1.5", 3)) p1.add_peer(PodDescriptor("Second IP", 5)) p2 = PartialView("Second IP", 4, 3) p2.add_peer(PodDescriptor("172.0.1.3", 0)) p2.add_peer(PodDescriptor("172.0.1.5", 1)) p2.add_peer(PodDescriptor("172.0.1.2", 2)) p2.add_peer(PodDescriptor("172.0.1.1", 4)) ######################## # P1 starts the exchange ######################## # 1) Increase by one the age of all neighbors p1.increment() # 2) Select neighbor Q with the highest age among all neighbors. oldest = p1.get_oldest_peer() # 3) Select l - 1 other random neighbors (meaning avoid oldest). request = p1.select_neighbors_for_request(oldest) # 4) Replace Q's entry with a new entry of age 0 and with P's address. request.add_peer_ip(p1.ip, allow_self_ip=True) self.assertTrue(request.is_full()) self.assertEqual(request.size, p1.shuffle_length) ################################################ # P2 receives neighbors and prepares a reply ################################################ reply = p2.select_neighbors_for_reply() self.assertTrue(request.is_full()) self.assertEqual(request.size, p1.shuffle_length) # Note that in p1 the oldest is p2 # p1 and p2 know two peers in common # p2 does not have an entry with p1's ip # p1.merge should: # - Discard 172.0.1.3 and 172.0.1.5 # - Put in unknown list 172.0.1.2, 172.0.1.1 # 6) I remove the oldest peer from my view p1.remove_peer(oldest) p1.merge(request, reply) self.assertTrue(p1.is_full()) for peer in reply.get_peer_list(): self.assertTrue(p1.contains(peer)) self.assertLessEqual(self.partialView.size, self.partialView.limit) # Test the exchange of views. # P1 plays the role of P while P2 plays the role of Q described in comments # def test_exchange_views_2(self): # # p1 = PartialView("First IP", 4, 3) # p1.add_peer(PodDescriptor("172.0.1.6", 0)) # p1.add_peer(PodDescriptor("172.0.1.3", 2)) # p1.add_peer(PodDescriptor("172.0.1.5", 3)) # p1.add_peer(PodDescriptor("Second IP", 5)) # # p2 = PartialView("Second IP", 4, 3) # p2.add_peer(PodDescriptor("172.0.1.3", 0)) # p2.add_peer(PodDescriptor("172.0.1.5", 1)) # p2.add_peer(PodDescriptor("172.0.1.2", 2)) # p2.add_peer(PodDescriptor("First IP", 4)) # # ######################## # # P1 starts the exchange # ######################## # # # 1) Increase by one the age of all neighbors # p1.increment() # # 2) Select neighbor Q with the highest age among all neighbors. # oldest = p1.get_oldest_peer() # # 3) Select l - 1 other random neighbors (meaning avoid oldest). # request = p1.select_neighbors_for_request(oldest) # # 4) Replace Q's entry with a new entry of age 0 and with P's address. # request.add_peer_ip(p1.ip, allow_self_ip=True) # # self.assertTrue(request.is_full()) # self.assertEqual(request.size, p1.shuffle_length) # # ################################################ # # P2 receives neighbors and prepares a reply # ################################################ # # reply = p2.select_neighbors_for_reply() # # self.assertTrue(request.is_full()) # self.assertEqual(request.size, p1.shuffle_length) # # # Note that in p1 the oldest is p2 # # p1 and p2 know two peers in common # # p2 does have an entry with p1's ip # # p1.merge should: # # - Discard 172.0.1.3 and 172.0.1.5 because are well known # # - Discard First IP because self ip is not allowed # # # 6) I remove the oldest peer from my view # p1.remove_peer(oldest) # p1.merge(request, reply) # # for peer in reply.get_peer_list(): # if peer != p1.ip: # self.assertTrue(p1.contains(peer)) # # self.assertLessEqual(self.partialView.size, self.partialView.limit) # Method get_oldest_peer should return a PodDescriptor def test_get_oldest_peer_should_return_none_if_empty_view(self): oldest = self.partialView.get_oldest_peer() self.assertEqual(oldest, None) # Method get_oldest_peer should return a PodDescriptor def test_get_oldest_peer_should_return_a_pod_descriptor(self): self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 1)) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) oldest = self.partialView.get_oldest_peer() self.assertTrue(isinstance(oldest, PodDescriptor)) # Method get_oldest_peer should return the peer with the highest age def test_get_oldest_peer(self): self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(PodDescriptor("172.0.1.4", 1)) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) oldest = self.partialView.get_oldest_peer() self.assertEqual(oldest.ip, "172.0.1.5") self.assertEqual(oldest.age, 4) def test_select_neighbors_for_request_should_return_a_non_full_view(self): oldest = PodDescriptor("172.0.1.4", 1) self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(oldest) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) neighbors = self.partialView.select_neighbors_for_request(oldest) self.assertFalse(neighbors.is_full()) self.assertEqual(neighbors.size, neighbors.shuffle_length - 1) def test_select_neighbors_for_request_should_not_contain_oldest_peer(self): oldest = PodDescriptor("172.0.1.4", 1) self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(oldest) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) neighbors = self.partialView.select_neighbors_for_request(oldest) self.assertFalse(neighbors.contains(oldest)) def test_select_neighbors_for_request_and_add_peer_should_return_full_view( self): oldest = PodDescriptor("172.0.1.4", 1) self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(oldest) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) neighbors = self.partialView.select_neighbors_for_request(oldest) neighbors.add_peer_ip(self.partialView.ip, allow_self_ip=True) self.assertEqual(neighbors.size, self.partialView.shuffle_length) self.assertTrue(neighbors.is_full()) def test_select_neighbors_for_reply_should_return_a_full_view(self): oldest = PodDescriptor("172.0.1.4", 1) self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(oldest) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) neighbors = self.partialView.select_neighbors_for_reply(oldest) self.assertTrue(neighbors.is_full()) self.assertEqual(neighbors.size, neighbors.shuffle_length) def test_select_neighbors_for_reply_should_contain_avoid_peer_if_size_eq_shuffle_length( self): oldest = PodDescriptor("172.0.1.4", 1) self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(oldest) neighbors = self.partialView.select_neighbors_for_reply(oldest) self.assertTrue(neighbors.is_full()) self.assertEqual(neighbors.size, neighbors.shuffle_length) def test_select_neighbors_for_reply_should_not_contain_oldest_peer(self): oldest = PodDescriptor("172.0.1.4", 1) self.partialView.add_peer(PodDescriptor("172.0.1.6", 2)) self.partialView.add_peer(oldest) self.partialView.add_peer(PodDescriptor("172.0.1.5", 4)) neighbors = self.partialView.select_neighbors_for_reply(oldest) self.assertFalse(neighbors.contains(oldest)) def test_empty_partial_view_to_json(self): jsonized = self.partialView.to_json() self.assertEqual( jsonized, { "ip": "172.0.1.0", "limit": 3, "shuffle_length": 2, "peer_list": [], "size": 0 }) def test_unmarshal_partial_view(self): for ip in self.ips: self.partialView.add_peer_ip(ip) jsonized = self.partialView.to_json() partial_view = PartialView.from_dict(jsonized) self.assertIsInstance(partial_view, PartialView) for peer in partial_view.peer_list: self.assertIsInstance(peer, PodDescriptor) self.assertEqual(partial_view.ip, self.partialView.ip) self.assertEqual(partial_view.size, 3) self.assertEqual(partial_view.limit, 3) for i in range(self.partialView.limit): self.assertEqual(partial_view.peer_list[i].ip, self.descriptors[i].ip) self.assertEqual(partial_view.peer_list[i].age, self.descriptors[i].age) # Every time the view size is checked if it is equal to the actual size def tearDown(self): self.assertEqual(len(self.partialView.peer_list), self.partialView.size)
class Cyclon(object): def __init__(self): self.ip = os.environ['MY_POD_IP'] self.k8s = KubernetesClient() self.api_version = 'v1' self.partialView = PartialView(self.ip) self.bootstrap() def bootstrap(self): self.bootstrap_exponential_backoff(5, 5) self.schedule_change(15, 15) def bootstrap_exponential_backoff(self, initial_delay, delay): logger.debug("Init", ip=self.ip, partialView=self.partialView) time.sleep(initial_delay) app_name = os.environ['APP'] attempt = 1 ips = self.k8s.list_pods_ips_by_field_selector( label_selector="app=" + app_name, field_selector="status.phase=Running") logger.debug("Bootstrapping", running_pods=ips, attempt=attempt) # Exponential backoff starts in case the number of running pods is lower than the partialView's limit. # TODO: Did I consider also that some pods might not be ready yet? # TODO: Consider that there is no need to have at least self.partialView.limit peers ready to start! # TODO: There can be peers running with an initial partial view of size < self.partialView.limit while len(ips) <= self.partialView.limit: attempt += 1 delay *= 2 time.sleep(delay) ips = self.k8s.list_pods_ips_by_field_selector( label_selector="app=epto", field_selector="status.phase=Running") logger.debug("Bootstrapping", running_pods=ips, attempt=attempt) # I populate the PartialView and I avoid to consider myself try: ips.remove(self.ip) except ValueError: logger.debug("self.ip was not there") while not self.partialView.is_full(): random_ip = random.choice(ips) # TODO: REPLACE WITH self.partialView.add_peer_ip(random_ip) self.partialView.add_peer( PodDescriptor(random_ip, random.randint(0, 9))) logger.debug("Bootstrapping", partialView=self.partialView) def schedule_change(self, initial_delay, interval): initial_delay = random.randint(0, initial_delay) time.sleep(initial_delay) scheduler = BackgroundScheduler() scheduler.add_job(self.shuffle_partial_view, 'interval', seconds=interval, max_instances=1) scheduler.start() def shuffle_partial_view(self): logger.debug("Shuffling", partialView=self.partialView) # 1) Increase by one the age of all neighbors logger.debug("Increase by one the age of all neighbors.") self.partialView.increment() logger.debug("Increment", partialView=self.partialView) # 2) Select neighbor Q with the highest age among all neighbors. logger.debug( "Select neighbor Q with the highest age among all neighbors.") oldest_peer = self.partialView.get_oldest_peer() logger.debug("SelectOldest", oldest_peer=oldest_peer) # 3) Select l - 1 other random neighbors (meaning avoid oldest). logger.debug( "Select l - 1 other random neighbors (meaning avoid oldest).") neighbors = self.partialView.select_neighbors_for_request(oldest_peer) logger.debug("SelectNeighbors", neighbors=neighbors) # 4) Replace Q's entry with a new entry of age 0 and with P's address. logger.debug( "Replace Q's entry with a new entry of age 0 and with P's address." ) neighbors.add_peer_ip(self.ip, allow_self_ip=True) logger.debug("AddMyself", neighbors=neighbors) try: # 5) Send the updated subset to peer Q. logger.debug("Send the updated subset to peer Q (oldest_peer).", oldest_peer=oldest_peer.ip) response = json.loads( self.send_message(oldest_peer.ip, 'exchange-view', neighbors)) received_partial_view = PartialView.from_dict(response.get('data')) logger.debug("Received", received_partial_view=received_partial_view) # 6) I remove the oldest peer from my view logger.debug("I remove the oldest peer from my view.", oldest_peer=oldest_peer.ip) self.partialView.remove_peer(oldest_peer) logger.debug("RemovedOldest", partialView=self.partialView) # 7) I merge my view with the one just received logger.debug("I merge my view with the one just received.") self.partialView.merge(neighbors, received_partial_view) logger.debug("Merged", partialView=self.partialView) except Timeout: logger.error("TimeoutException: Request to " + str(oldest_peer.ip) + " timed out.") def send_message(self, destination_ip, path, data): destination = os.getenv('TEST_IP', format_address(destination_ip, 5000)) m = Message(format_address(self.ip, 5000), destination, data) logger.debug("Request", request=m.to_json()) ret = requests.post(m.destination + '/' + self.api_version + '/' + path, json=m.to_json(), timeout=5) logger.debug("Response", response=ret.content) return ret.content