def cache_exitnodes_to_disk(self):
"""
Write a copy of the exit_candidates to the file self.exitnode_cache.
:returns: None
"""
exit_nodes = Network()
for peer in self.get_candidates(PEER_FLAG_EXIT_BT):
exit_nodes.add_verified_peer(peer)
self.logger.debug('Writing exit nodes to cache: %s',
self.exitnode_cache)
with open(self.exitnode_cache, 'wb') as cache:
cache.write(exit_nodes.snapshot())
def __init__(self, configuration, endpoint_override=None, enable_statistics=False, extra_communities=None):
if endpoint_override:
self.endpoint = endpoint_override
else:
self.endpoint = UDPEndpoint(port=configuration['port'], ip=configuration['address'])
self.endpoint.open()
if enable_statistics:
self.endpoint = StatisticsEndpoint(self, self.endpoint)
self.network = Network()
# Load/generate keys
self.keys = {}
for key_block in configuration['keys']:
if key_block['file'] and isfile(key_block['file']):
with open(key_block['file'], 'r') as f:
content = f.read()
try:
# IPv8 Standardized bin format
self.keys[key_block['alias']] = Peer(default_eccrypto.key_from_private_bin(content))
except ValueError:
try:
# Try old Tribler M2Crypto PEM format
content = b64decode(content[31:-30].replace('\n', ''))
peer = Peer(M2CryptoSK(keystring=content))
peer.mid # This will error out if the keystring is not M2Crypto
self.keys[key_block['alias']] = peer
except:
# Try old LibNacl format
content = "LibNaCLSK:" + content
self.keys[key_block['alias']] = Peer(default_eccrypto.key_from_private_bin(content))
else:
self.keys[key_block['alias']] = Peer(default_eccrypto.generate_key(key_block['generation']))
if key_block['file']:
with open(key_block['file'], 'w') as f:
f.write(self.keys[key_block['alias']].key.key_to_bin())
# Setup logging
logging.basicConfig(**configuration['logger'])
self.overlay_lock = RLock()
self.strategies = []
self.overlays = []
for overlay in configuration['overlays']:
overlay_class = _COMMUNITIES.get(overlay['class'], (extra_communities or {}).get(overlay['class']))
my_peer = self.keys[overlay['key']]
overlay_instance = overlay_class(my_peer, self.endpoint, self.network, **overlay['initialize'])
self.overlays.append(overlay_instance)
for walker in overlay['walkers']:
strategy_class = _WALKERS.get(walker['strategy'],
overlay_instance.get_available_strategies().get(walker['strategy']))
args = walker['init']
target_peers = walker['peers']
self.strategies.append((strategy_class(overlay_instance, **args), target_peers))
for config in overlay['on_start']:
reactor.callWhenRunning(getattr(overlay_instance, config[0]), *config[1:])
self.state_machine_lc = LoopingCall(self.on_tick)
self.state_machine_lc.start(configuration['walker_interval'], False)
async def run(self):
await super().run()
await self.get_component(ReporterComponent)
self._ipv8_component = await self.require_component(Ipv8Component)
metadata_store_component = await self.require_component(
MetadataStoreComponent)
torrent_checker_component = await self.require_component(
TorrentCheckerComponent)
config = self.session.config
community = PopularityCommunity(
self._ipv8_component.peer,
self._ipv8_component.ipv8.endpoint,
Network(),
settings=config.popularity_community,
rqc_settings=config.remote_query_community,
metadata_store=metadata_store_component.mds,
torrent_checker=torrent_checker_component.torrent_checker)
self.community = community
self._ipv8_component.initialise_community_by_default(
community, default_random_walk_max_peers=30)
self._ipv8_component.ipv8.add_strategy(community,
RemovePeers(community),
INFINITE)
async def run(self):
await super().run()
await self.get_component(ReporterComponent)
config = self.session.config
notifier = self.session.notifier
self._ipv8_component = await self.require_component(Ipv8Component)
metadata_store_component = await self.require_component(
MetadataStoreComponent)
tag_component = await self.get_component(TagComponent)
giga_channel_cls = GigaChannelTestnetCommunity if config.general.testnet else GigaChannelCommunity
community = giga_channel_cls(
self._ipv8_component.peer,
self._ipv8_component.ipv8.endpoint,
Network(),
notifier=notifier,
settings=config.chant,
rqc_settings=config.remote_query_community,
metadata_store=metadata_store_component.mds,
max_peers=50,
tags_db=tag_component.tags_db if tag_component else None)
self.community = community
self._ipv8_component.initialise_community_by_default(
community, default_random_walk_max_peers=30)
self._ipv8_component.ipv8.add_strategy(community,
RemovePeers(community),
INFINITE)
def __init__(self, endpoint):
my_peer = Peer(default_eccrypto.generate_key(u"very-low"))
self.signature_length = default_eccrypto.get_signature_length(
my_peer.public_key)
super(EndpointServer, self).__init__(my_peer, endpoint, Network())
self.churn_strategy = SimpleChurn(self)
self.churn_lc = self.register_task(
"churn",
LoopingCall(self.churn_strategy.take_step)).start(30.0, now=False)
def __init__(self, endpoint):
my_peer = Peer(default_eccrypto.generate_key(u"very-low"))
self.signature_length = default_eccrypto.get_signature_length(
my_peer.public_key)
super(EndpointServer, self).__init__(my_peer, endpoint, Network())
self.churn_strategy = SimpleChurn(self)
self.churn_task = self.register_task("churn",
self.churn_strategy.take_step,
interval=30)
def __init__(self, crypto_curve, overlay_class, *args, **kwargs):
self.endpoint = AutoMockEndpoint()
self.endpoint.open()
self.network = Network()
self.my_peer = Peer(ECCrypto().generate_key(crypto_curve), self.endpoint.wan_address)
self.overlay = overlay_class(self.my_peer, self.endpoint, self.network, *args, **kwargs)
self.discovery = MockWalk(self.overlay)
self.overlay.my_estimated_wan = self.endpoint.wan_address
self.overlay.my_estimated_lan = self.endpoint.lan_address
async def sanitize_network(self, session):
# We disable the discovery communities in this session since we don't want to walk to the live network
for overlay in session.ipv8.overlays:
if isinstance(overlay, DiscoveryCommunity):
await overlay.unload()
session.ipv8.overlays = []
session.ipv8.strategies = []
# Also reset the IPv8 network
session.ipv8.network = Network()
def restore_exitnodes_from_disk(self):
"""
Send introduction requests to peers stored in the file self.exitnode_cache.
:returns: None
"""
if self.exitnode_cache.is_file():
self.logger.debug('Loading exit nodes from cache: %s',
self.exitnode_cache)
exit_nodes = Network()
with self.exitnode_cache.open('rb') as cache:
exit_nodes.load_snapshot(cache.read())
for exit_node in exit_nodes.get_walkable_addresses():
self.endpoint.send(exit_node,
self.create_introduction_request(exit_node))
else:
self.logger.warning(
'Could not retrieve backup exitnode cache, file does not exist!'
)
def __init__(self, endpoint):
my_peer = Peer(default_eccrypto.generate_key(u"very-low"))
self.signature_length = default_eccrypto.get_signature_length(
my_peer.public_key)
super(EndpointServer, self).__init__(my_peer, endpoint, Network())
self.endpoint.add_listener(
self
) # Listen to all incoming packets (not just the fake community_id).
self.churn_strategy = SimpleChurn(self)
self.churn_task = self.register_task("churn",
self.churn_strategy.take_step,
interval=30)
def __init__(self, my_peer, endpoint, network, metadata_store, **kwargs):
kwargs["settings"] = kwargs.get("settings", GigaChannelCommunitySettings())
self.notifier = kwargs.pop("notifier", None)
# ACHTUNG! We create a separate instance of Network for this community because it
# walks aggressively and wants lots of peers, which can interfere with other communities
super().__init__(my_peer, endpoint, Network(), metadata_store, **kwargs)
# This set contains all the peers that we queried for subscribed channels over time.
# It is emptied regularly. The purpose of this set is to work as a filter so we never query the same
# peer twice. If we do, this should happen really rarely
# TODO: use Bloom filter here instead. We actually *want* it to be all-false-positives eventually.
self.queried_peers = set()
self.discovery_booster = DiscoveryBooster(timeout_in_sec=30)
self.discovery_booster.apply(self)
def __init__(self, my_peer, endpoint, network, **kwargs):
self.torrent_checker = kwargs.pop('torrent_checker', None)
# Creating a separate instance of Network for this community to find more peers
super().__init__(my_peer, endpoint, Network(), **kwargs)
self.add_message_handler(TorrentsHealthPayload,
self.on_torrents_health)
self.logger.info('Popularity Community initialized (peer mid %s)',
hexlify(self.my_peer.mid))
self.register_task(
"gossip_popular_torrents",
self.gossip_popular_torrents_health,
interval=PopularityCommunity.GOSSIP_INTERVAL_FOR_POPULAR_TORRENTS)
self.register_task(
"gossip_random_torrents",
self.gossip_random_torrents_health,
interval=PopularityCommunity.GOSSIP_INTERVAL_FOR_RANDOM_TORRENTS)
def __init__(self,
configuration,
endpoint_override=None,
enable_statistics=False,
extra_communities=None):
super(IPv8, self).__init__()
self.configuration = configuration
if endpoint_override:
self.endpoint = endpoint_override
else:
self.endpoint = DispatcherEndpoint(["UDPIPv4"],
UDPIPv4={
'port':
configuration['port'],
'ip':
configuration['address']
})
if enable_statistics:
self.endpoint = StatisticsEndpoint(self.endpoint)
if any([
overlay.get('initialize', {}).get('anonymize')
for overlay in configuration['overlays']
]):
self.endpoint = TunnelEndpoint(self.endpoint)
self.network = Network()
# Load/generate keys
self.keys = {}
for key_block in configuration['keys']:
if key_block['file'] and isfile(key_block['file']):
with open(key_block['file'], 'rb') as f:
content = f.read()
try:
# IPv8 Standardized bin format
self.keys[key_block['alias']] = Peer(
default_eccrypto.key_from_private_bin(content))
except ValueError:
try:
# Try old Tribler M2Crypto PEM format
content = b64decode(content[31:-30].replace(
'\n', ''))
peer = Peer(M2CryptoSK(keystring=content))
peer.mid # This will error out if the keystring is not M2Crypto
self.keys[key_block['alias']] = peer
except Exception:
# Try old LibNacl format
content = "LibNaCLSK:" + content
self.keys[key_block['alias']] = Peer(
default_eccrypto.key_from_private_bin(
content))
else:
self.keys[key_block['alias']] = Peer(
default_eccrypto.generate_key(key_block['generation']))
if key_block['file']:
with open(key_block['file'], 'wb') as f:
f.write(
self.keys[key_block['alias']].key.key_to_bin())
# Setup logging
logging.basicConfig(**configuration['logger'])
self.overlay_lock = RLock()
self.strategies = []
self.overlays = []
self.on_start = []
for overlay in configuration['overlays']:
overlay_class = _COMMUNITIES.get(overlay['class'],
(extra_communities
or {}).get(overlay['class']))
my_peer = self.keys[overlay['key']]
overlay_instance = overlay_class(my_peer, self.endpoint,
self.network,
**overlay['initialize'])
self.overlays.append(overlay_instance)
for walker in overlay['walkers']:
strategy_class = _WALKERS.get(
walker['strategy'],
overlay_instance.get_available_strategies().get(
walker['strategy']))
args = walker['init']
target_peers = walker['peers']
self.strategies.append(
(strategy_class(overlay_instance,
**args), target_peers))
for config in overlay['on_start']:
self.on_start.append((getattr(overlay_instance,
config[0]), config[1:]))
for bootstrapper in overlay['bootstrappers']:
bootstrapper_class = _BOOTSTRAPPERS.get(
bootstrapper['class'])
if bootstrapper_class:
overlay_instance.bootstrappers.append(
bootstrapper_class(**bootstrapper['init']))
self.walk_interval = configuration['walker_interval']
self.state_machine_task = None
class IPv8(object):
def __init__(self,
configuration,
endpoint_override=None,
enable_statistics=False):
if endpoint_override:
self.endpoint = endpoint_override
else:
self.endpoint = UDPEndpoint(port=configuration['port'],
ip=configuration['address'])
self.endpoint.open()
if enable_statistics:
self.endpoint = StatisticsEndpoint(self, self.endpoint)
self.network = Network()
# Load/generate keys
self.keys = {}
for key_block in configuration['keys']:
if key_block['file'] and isfile(key_block['file']):
with open(key_block['file'], 'r') as f:
content = f.read()
try:
# IPv8 Standardized bin format
self.keys[key_block['alias']] = Peer(
ECCrypto().key_from_private_bin(content))
except ValueError:
try:
# Try old Tribler M2Crypto PEM format
content = content[31:-30].replace(
'\n', '').decode("BASE64")
peer = Peer(M2CryptoSK(keystring=content))
peer.mid # This will error out if the keystring is not M2Crypto
self.keys[key_block['alias']] = peer
except:
# Try old LibNacl format
content = "LibNaCLSK:" + content
self.keys[key_block['alias']] = Peer(
ECCrypto().key_from_private_bin(content))
else:
self.keys[key_block['alias']] = Peer(
ECCrypto().generate_key(key_block['generation']))
if key_block['file']:
with open(key_block['file'], 'w') as f:
f.write(
self.keys[key_block['alias']].key.key_to_bin())
# Setup logging
logging.basicConfig(**configuration['logger'])
self.overlay_lock = RLock()
self.strategies = []
self.overlays = []
for overlay in configuration['overlays']:
overlay_class = _COMMUNITIES[overlay['class']]
my_peer = self.keys[overlay['key']]
overlay_instance = overlay_class(my_peer, self.endpoint,
self.network,
**overlay['initialize'])
self.overlays.append(overlay_instance)
for walker in overlay['walkers']:
strategy_class = _WALKERS[walker['strategy']]
args = walker['init']
target_peers = walker['peers']
self.strategies.append(
(strategy_class(overlay_instance,
**args), target_peers))
for config in overlay['on_start']:
reactor.callWhenRunning(
getattr(overlay_instance, config[0]), *config[1:])
self.state_machine_lc = LoopingCall(self.on_tick)
self.state_machine_lc.start(configuration['walker_interval'],
False)
def on_tick(self):
if self.endpoint.is_open():
with self.overlay_lock:
for strategy, target_peers in self.strategies:
service = strategy.overlay.master_peer.mid
peer_count = len(
self.network.get_peers_for_service(service))
if (target_peers == -1) or (peer_count < target_peers):
strategy.take_step(service)
def unload_overlay(self, instance):
with self.overlay_lock:
self.overlays = [
overlay for overlay in self.overlays if overlay != instance
]
self.strategies = [(strategy, target_peers)
for (strategy,
target_peers) in self.strategies
if strategy.overlay != instance]
return maybeDeferred(instance.unload)
@inlineCallbacks
def stop(self, stop_reactor=True):
self.state_machine_lc.stop()
with self.overlay_lock:
unload_list = [
self.unload_overlay(overlay)
for overlay in self.overlays[:]
]
yield DeferredList(unload_list)
yield self.endpoint.close()
if stop_reactor:
reactor.callFromThread(reactor.stop)
def setUp(self):
self.network = Network()
class TestNetwork(unittest.TestCase):
peers = [_generate_peer() for _ in range(4)]
def setUp(self):
self.network = Network()
def test_discover_address(self):
"""
Check registration of introducer and introduced when a new address is discovered.
The introducer should be verified and not walkable.
The introduced should not be verified and walkable.
"""
self.network.discover_address(self.peers[0], self.peers[1].address)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[1].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[1], self.network.verified_peers)
self.assertIn(self.peers[1].address,
self.network.get_introductions_from(self.peers[0]))
self.assertTrue(
self.network.graph.has_edge(b64encode(self.peers[0].mid),
self.peers[1].address))
def test_discover_address_duplicate(self):
"""
Check registration of introducer and introduced when the same address is discovered twice.
"""
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.discover_address(self.peers[0], self.peers[1].address)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[1].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[1], self.network.verified_peers)
self.assertIn(self.peers[1].address,
self.network.get_introductions_from(self.peers[0]))
self.assertTrue(
self.network.graph.has_edge(b64encode(self.peers[0].mid),
self.peers[1].address))
def test_discover_address_known(self):
"""
Check if an address is already known, the network isn't updated.
"""
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.discover_address(self.peers[2], self.peers[1].address)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[1].address,
self.network.get_walkable_addresses())
self.assertNotIn(self.peers[2].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[1], self.network.verified_peers)
self.assertIn(self.peers[2], self.network.verified_peers)
self.assertIn(self.peers[1].address,
self.network.get_introductions_from(self.peers[0]))
self.assertTrue(
self.network.graph.has_edge(b64encode(self.peers[0].mid),
self.peers[1].address))
def test_discover_address_known_parent_deceased(self):
"""
Check if an address is already known, the new introducer adopts the introduced.
"""
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.remove_peer(self.peers[0])
self.network.discover_address(self.peers[2], self.peers[1].address)
self.assertIn(self.peers[1].address,
self.network.get_walkable_addresses())
self.assertNotIn(self.peers[2].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[2], self.network.verified_peers)
self.assertNotIn(self.peers[1], self.network.verified_peers)
self.assertIn(self.peers[1].address,
self.network.get_introductions_from(self.peers[2]))
self.assertTrue(
self.network.graph.has_edge(b64encode(self.peers[2].mid),
self.peers[1].address))
def test_discover_address_blacklist(self):
"""
Check if an address is in the blacklist, the network isn't updated.
"""
self.network.blacklist.append(self.peers[2].address)
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.discover_address(self.peers[0], self.peers[2].address)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[1].address,
self.network.get_walkable_addresses())
self.assertNotIn(self.peers[2].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[1], self.network.verified_peers)
self.assertNotIn(self.peers[2], self.network.verified_peers)
self.assertIn(self.peers[1].address,
self.network.get_introductions_from(self.peers[0]))
self.assertTrue(
self.network.graph.has_edge(b64encode(self.peers[0].mid),
self.peers[1].address))
def test_discover_address_multiple(self):
"""
Check if a single peer can perform multiple introductions.
"""
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.discover_address(self.peers[0], self.peers[2].address)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
for other in [1, 2]:
self.assertIn(self.peers[other].address,
self.network.get_walkable_addresses())
self.assertNotIn(self.peers[other], self.network.verified_peers)
self.assertIn(self.peers[other].address,
self.network.get_introductions_from(self.peers[0]))
self.assertTrue(
self.network.graph.has_edge(b64encode(self.peers[0].mid),
self.peers[other].address))
def test_discover_services(self):
"""
Check if services are properly registered for a peer.
"""
service = "".join([chr(i) for i in range(20)])
self.network.discover_services(self.peers[0], [service])
self.network.add_verified_peer(self.peers[0])
self.assertIn(service,
self.network.get_services_for_peer(self.peers[0]))
self.assertIn(self.peers[0],
self.network.get_peers_for_service(service))
def test_discover_services_unverified(self):
"""
Check if services are properly registered for an unverified peer.
You can query the services of an unverified peer, but it won't show up as a reachable peer for a service.
"""
service = "".join([chr(i) for i in range(20)])
self.network.discover_services(self.peers[0], [service])
self.assertIn(service,
self.network.get_services_for_peer(self.peers[0]))
self.assertNotIn(self.peers[0],
self.network.get_peers_for_service(service))
def test_discover_services_update(self):
"""
Check if services are properly combined for a peer.
"""
service1 = "".join([chr(i) for i in range(20)])
service2 = "".join([chr(i) for i in range(20, 40)])
self.network.discover_services(self.peers[0], [service1])
self.network.discover_services(self.peers[0], [service2])
self.network.add_verified_peer(self.peers[0])
self.assertIn(service1,
self.network.get_services_for_peer(self.peers[0]))
self.assertIn(service2,
self.network.get_services_for_peer(self.peers[0]))
self.assertIn(self.peers[0],
self.network.get_peers_for_service(service1))
self.assertIn(self.peers[0],
self.network.get_peers_for_service(service2))
def test_discover_services_update_overlap(self):
"""
Check if services are properly combined when discovered services overlap.
"""
service1 = "".join([chr(i) for i in range(20)])
service2 = "".join([chr(i) for i in range(20, 40)])
self.network.discover_services(self.peers[0], [service1])
self.network.discover_services(self.peers[0], [service1, service2])
self.network.add_verified_peer(self.peers[0])
self.assertIn(service1,
self.network.get_services_for_peer(self.peers[0]))
self.assertIn(service2,
self.network.get_services_for_peer(self.peers[0]))
self.assertIn(self.peers[0],
self.network.get_peers_for_service(service1))
self.assertIn(self.peers[0],
self.network.get_peers_for_service(service2))
def test_add_verified_peer_new(self):
"""
Check if a new verified peer can be added to the network.
"""
self.network.add_verified_peer(self.peers[0])
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertListEqual([],
self.network.get_introductions_from(
self.peers[0]))
self.assertTrue(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
def test_add_verified_peer_blacklist(self):
"""
Check if a new verified peer can be added to the network.
"""
self.network.blacklist.append(self.peers[0].address)
self.network.add_verified_peer(self.peers[0])
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertNotIn(self.peers[0], self.network.verified_peers)
self.assertFalse(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
def test_add_verified_peer_duplicate(self):
"""
Check if an already verified (by slightly changed) peer doesn't cause duplicates in the network.
"""
self.network.add_verified_peer(self.peers[0])
self.peers[0].update_clock(1)
self.network.add_verified_peer(self.peers[0])
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertListEqual([],
self.network.get_introductions_from(
self.peers[0]))
self.assertTrue(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
def test_add_verified_peer_promote(self):
"""
Check if a peer can be promoted from an address to a verified peer.
"""
self.network.discover_address(self.peers[1], self.peers[0].address)
self.network.add_verified_peer(self.peers[0])
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertIn(self.peers[0], self.network.verified_peers)
self.assertListEqual([],
self.network.get_introductions_from(
self.peers[0]))
self.assertTrue(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
self.assertFalse(self.network.graph.has_node(self.peers[0].address))
def test_get_verified_by_address(self):
"""
Check if we can find a peer in our network by its address.
"""
self.network.add_verified_peer(self.peers[0])
self.assertEqual(
self.peers[0],
self.network.get_verified_by_address(self.peers[0].address))
def test_get_verified_by_public_key(self):
"""
Check if we can find a peer in our network by its public key.
"""
self.network.add_verified_peer(self.peers[0])
self.assertEqual(
self.peers[0],
self.network.get_verified_by_public_key_bin(
self.peers[0].public_key.key_to_bin()))
def test_remove_by_address(self):
"""
Check if we can remove a peer from our network by its address.
"""
self.network.add_verified_peer(self.peers[0])
self.network.discover_services(self.peers[0], ["0" * 20])
self.network.remove_by_address(self.peers[0].address)
self.assertNotIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertEqual(set(),
self.network.get_services_for_peer(self.peers[0]))
self.assertFalse(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
def test_remove_by_address_unverified(self):
"""
Check if we can remove an unverified peer from our network by its address.
"""
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.remove_by_address(self.peers[1].address)
self.assertNotIn(self.peers[1].address,
self.network.get_walkable_addresses())
self.assertFalse(self.network.graph.has_node(self.peers[1].address))
def test_remove_by_address_unknown(self):
"""
Removing unknown peers should not affect other peers.
"""
self.network.add_verified_peer(self.peers[0])
previous_walkable = self.network.get_walkable_addresses()
previous_verified = self.network.verified_peers
self.network.remove_by_address(self.peers[1].address)
self.assertEqual(previous_walkable,
self.network.get_walkable_addresses())
self.assertEqual(previous_verified, self.network.verified_peers)
def test_remove_by_address_no_services(self):
"""
Check if we can remove a peer from our network if it doesn't have services by address.
"""
self.network.add_verified_peer(self.peers[0])
self.network.remove_by_address(self.peers[0].address)
self.assertNotIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertFalse(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
def test_remove_peer(self):
"""
Check if we can remove a peer from our network.
"""
self.network.add_verified_peer(self.peers[0])
self.network.discover_services(self.peers[0], ["0" * 20])
self.network.remove_peer(self.peers[0])
self.assertNotIn(self.peers[0], self.network.verified_peers)
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertEqual(set(),
self.network.get_services_for_peer(self.peers[0]))
self.assertFalse(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
def test_remove_peer_external(self):
"""
Check if we can remove an externally created peer from our network.
"""
self.network.discover_address(self.peers[1], self.peers[0].address)
self.network.remove_peer(self.peers[0])
self.assertNotIn(self.peers[0].address,
self.network.get_walkable_addresses())
self.assertFalse(
self.network.graph.has_node(b64encode(self.peers[0].mid)))
self.assertFalse(self.network.graph.has_node(self.peers[0].address))
def test_remove_peer_unknown(self):
"""
Removing unknown peers should not affect other peers.
"""
self.network.add_verified_peer(self.peers[0])
previous_walkable = self.network.get_walkable_addresses()
previous_verified = self.network.verified_peers
self.network.remove_peer(self.peers[1])
self.assertEqual(previous_walkable,
self.network.get_walkable_addresses())
self.assertEqual(previous_verified, self.network.verified_peers)
def test_get_walkable_by_service(self):
"""
Check if we can retrieve walkable addresses by parent service id.
"""
service = "".join([chr(i) for i in range(20)])
self.network.discover_address(self.peers[2], self.peers[3].address)
self.network.discover_address(self.peers[0], self.peers[1].address)
self.network.discover_services(self.peers[0], [service])
self.assertEqual([self.peers[1].address],
self.network.get_walkable_addresses(service))
def __init__(self, endpoint):
my_peer = Peer(ECCrypto().generate_key(u"very-low"))
super(EndpointServer, self).__init__(my_peer, endpoint, Network())
self.churn_lc = self.register_task("churn", LoopingCall(self.do_churn)).start(5.0, now=False)
self.churn_strategy = RandomChurn(self)
self.crypto = ECCrypto()
def __init__(self):
self.fetch_next_called = False
self.send_random_to_called = []
self.get_peers_return = []
self.network = Network()
def __init__(self):
endpoint = AutoMockEndpoint()
endpoint.open()
network = Network()
peer = Peer(ECCrypto().generate_key(u"very-low"), endpoint.wan_address)
super(MockCommunity, self).__init__(peer, endpoint, network)
def __init__(self):
self.exit_candidates = []
self.network = Network()
def __init__(self):
self.exit_candidates = []
self.candidates = {}
self.network = Network()
self.send_introduction_request = Mock()
