def test_split_bucket_cache_update(self):
"""
Ensures that if there are cached contacts for the split bucket then
the two new buckets are topped up, the old cache is removed and two
new caches created (one for each of the new buckets).
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(0, 100)
contact1 = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact1.network_id = hex(20)
bucket.add_contact(contact1)
contact2 = PeerNode(PUBLIC_KEY, '192.168.0.2', 8888, 0)
contact2.network_id = hex(40)
bucket.add_contact(contact2)
contact3 = PeerNode(PUBLIC_KEY, '192.168.0.3', 8888, 0)
contact3.network_id = hex(60)
bucket.add_contact(contact3)
contact4 = PeerNode(PUBLIC_KEY, '192.168.0.4', 8888, 0)
contact4.network_id = hex(80)
bucket.add_contact(contact4)
r._buckets[0] = bucket
# Add two items to the cache.
cache = []
cache_contact1 = PeerNode(PUBLIC_KEY, '192.168.0.5', 8888, 0)
cache_contact1.network_id = hex(10)
cache.append(cache_contact1)
cache_contact2 = PeerNode(PUBLIC_KEY, '192.168.0.6', 8888, 0)
cache_contact2.network_id = hex(70)
cache.append(cache_contact2)
r._replacement_cache = {
(0, 100): cache
}
# Two buckets!
r._split_bucket(0)
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(3, len(bucket1._contacts))
self.assertEqual(3, len(bucket2._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(contact2, bucket1._contacts[1])
self.assertEqual(cache_contact1, bucket1._contacts[2])
self.assertEqual(contact3, bucket2._contacts[0])
self.assertEqual(contact4, bucket2._contacts[1])
self.assertEqual(cache_contact2, bucket2._contacts[2])
# Ensure the _replacement_cache is in the expected state.
self.assertEqual(2, len(r._replacement_cache))
self.assertNotIn((0, 100), r._replacement_cache)
self.assertIn((0, 50), r._replacement_cache)
self.assertIn((50, 100), r._replacement_cache)
def test_bucket_index_multiple_buckets(self):
"""
Ensures the expected index is returned when multiple buckets exist.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
r._split_bucket(0)
split_point = int((2 ** 512) / 2)
lower_key = hex(split_point - 1)[2:]
higher_key = hex(split_point + 1)[2:]
expected_lower_index = 0
expected_higher_index = 1
actual_lower_index = r._bucket_index(lower_key)
actual_higher_index = r._bucket_index(higher_key)
self.assertEqual(expected_lower_index, actual_lower_index)
self.assertEqual(expected_higher_index, actual_higher_index)
def test_kbucket_index_multiple_buckets(self):
"""
Ensures the expected index is returned when multiple buckets exist.
"""
parent_node_id = 'abc'
r = RoutingTable(parent_node_id)
r._split_bucket(0)
split_point = (2 ** 512) / 2
lower_key = split_point - 1
higher_key = split_point + 1
expected_lower_index = 0
expected_higher_index = 1
actual_lower_index = r._kbucket_index(lower_key)
actual_higher_index = r._kbucket_index(higher_key)
self.assertEqual(expected_lower_index, actual_lower_index)
self.assertEqual(expected_higher_index, actual_higher_index)
def test_split_bucket(self):
"""
Ensures that the correct bucket is split in two and that the contacts
are found in the right place.
"""
parent_node_id = 'abc'
r = RoutingTable(parent_node_id)
bucket = KBucket(0, 10)
contact1 = Contact(2, '192.168.0.1', 9999, 0)
bucket.add_contact(contact1)
contact2 = Contact(4, '192.168.0.2', 8888, 0)
bucket.add_contact(contact2)
contact3 = Contact(6, '192.168.0.3', 8888, 0)
bucket.add_contact(contact3)
contact4 = Contact(8, '192.168.0.4', 8888, 0)
bucket.add_contact(contact4)
r._buckets[0] = bucket
# Sanity check
self.assertEqual(1, len(r._buckets))
r._split_bucket(0)
# Two buckets!
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(2, len(bucket1._contacts))
self.assertEqual(2, len(bucket2._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(contact2, bucket1._contacts[1])
self.assertEqual(contact3, bucket2._contacts[0])
self.assertEqual(contact4, bucket2._contacts[1])
# Split the new bucket again, ensuring that only the target bucket is
# modified.
r._split_bucket(1)
self.assertEqual(3, len(r._buckets))
bucket3 = r._buckets[2]
# kbucket1 remains un-changed
self.assertEqual(2, len(bucket1._contacts))
# kbucket2 only contains the lower half of its original contacts.
self.assertEqual(1, len(bucket2._contacts))
self.assertEqual(contact3, bucket2._contacts[0])
# kbucket3 now contains the upper half of the original contacts.
self.assertEqual(1, len(bucket3._contacts))
self.assertEqual(contact4, bucket3._contacts[0])
# Split the bucket at position 0 and ensure the resulting buckets are
# in the correct position with the correct content.
r._split_bucket(0)
self.assertEqual(4, len(r._buckets))
bucket1, bucket2, bucket3, bucket4 = r._buckets
self.assertEqual(1, len(bucket1._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(1, len(bucket2._contacts))
self.assertEqual(contact2, bucket2._contacts[0])
self.assertEqual(1, len(bucket3._contacts))
self.assertEqual(contact3, bucket3._contacts[0])
self.assertEqual(1, len(bucket4._contacts))
self.assertEqual(contact4, bucket4._contacts[0])
def test_split_bucket_cache_too_full(self):
"""
If the split occurs and there are too many contacts and cached
contacts for a new bucket, the remainder or cached contacts are added
to the cache for the new bucket.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(0, 100)
low_contacts = []
high_contacts = []
for i in range(10):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
bucket.add_contact(contact)
low_contacts.append(contact)
for i in range(50, 60):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
bucket.add_contact(contact)
high_contacts.append(contact)
r._buckets[0] = bucket
# Add items to the cache.
cache = []
low_cache = []
high_cache = []
for i in range(10, 30):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
cache.append(contact)
low_cache.append(contact)
for i in range(60, 80):
contact = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact.network_id = hex(i)
cache.append(contact)
high_cache.append(contact)
r._replacement_cache = {
(0, 100): cache
}
# Two buckets!
r._split_bucket(0)
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(20, len(bucket1._contacts))
self.assertEqual(20, len(bucket2._contacts))
for i in range(10):
self.assertEqual(low_contacts[i], bucket1._contacts[i])
self.assertEqual(low_cache[i], bucket1._contacts[i + 10])
for i in range(10):
self.assertEqual(high_contacts[i], bucket2._contacts[i])
self.assertEqual(high_cache[i], bucket2._contacts[i + 10])
# Ensure the _replacement_cache is in the expected state.
self.assertEqual(2, len(r._replacement_cache))
self.assertNotIn((0, 100), r._replacement_cache)
self.assertIn((0, 50), r._replacement_cache)
self.assertIn((50, 100), r._replacement_cache)
self.assertEqual(10, len(r._replacement_cache[(0, 50)]))
self.assertEqual(10, len(r._replacement_cache[(50, 100)]))
for i in range(10):
self.assertEqual(low_cache[i + 10],
r._replacement_cache[(0, 50)][i])
self.assertEqual(high_cache[i + 10],
r._replacement_cache[(50, 100)][i])
def test_split_bucket(self):
"""
Ensures that the correct bucket is split in two and that the contacts
are found in the right place.
"""
parent_node_id = 'deadbeef'
r = RoutingTable(parent_node_id)
bucket = Bucket(0, 100)
contact1 = PeerNode(PUBLIC_KEY, '192.168.0.1', 9999, 0)
contact1.network_id = hex(20)
bucket.add_contact(contact1)
contact2 = PeerNode(PUBLIC_KEY, '192.168.0.2', 8888, 0)
contact2.network_id = hex(40)
bucket.add_contact(contact2)
contact3 = PeerNode(PUBLIC_KEY, '192.168.0.3', 8888, 0)
contact3.network_id = hex(60)
bucket.add_contact(contact3)
contact4 = PeerNode(PUBLIC_KEY, '192.168.0.4', 8888, 0)
contact4.network_id = hex(80)
bucket.add_contact(contact4)
r._buckets[0] = bucket
# Sanity check
self.assertEqual(1, len(r._buckets))
r._split_bucket(0)
# Two buckets!
self.assertEqual(2, len(r._buckets))
bucket1 = r._buckets[0]
bucket2 = r._buckets[1]
# Ensure the right number of contacts are in each bucket in the correct
# order (most recently added at the head of the list).
self.assertEqual(2, len(bucket1._contacts))
self.assertEqual(2, len(bucket2._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(contact2, bucket1._contacts[1])
self.assertEqual(contact3, bucket2._contacts[0])
self.assertEqual(contact4, bucket2._contacts[1])
# Split the new bucket again, ensuring that only the target bucket is
# modified.
r._split_bucket(1)
self.assertEqual(3, len(r._buckets))
bucket3 = r._buckets[2]
# bucket1 remains un-changed
self.assertEqual(2, len(bucket1._contacts))
# bucket2 only contains the lower half of its original contacts.
self.assertEqual(1, len(bucket2._contacts))
self.assertEqual(contact3, bucket2._contacts[0])
# bucket3 now contains the upper half of the original contacts.
self.assertEqual(1, len(bucket3._contacts))
self.assertEqual(contact4, bucket3._contacts[0])
# Split the bucket at position 0 and ensure the resulting buckets are
# in the correct position with the correct content.
r._split_bucket(0)
self.assertEqual(4, len(r._buckets))
bucket1, bucket2, bucket3, bucket4 = r._buckets
self.assertEqual(1, len(bucket1._contacts))
self.assertEqual(contact1, bucket1._contacts[0])
self.assertEqual(1, len(bucket2._contacts))
self.assertEqual(contact2, bucket2._contacts[0])
self.assertEqual(1, len(bucket3._contacts))
self.assertEqual(contact3, bucket3._contacts[0])
self.assertEqual(1, len(bucket4._contacts))
self.assertEqual(contact4, bucket4._contacts[0])