def __init__(self, reactor: ReactorBase, my_peer: PeerId, server_factory: 'HathorServerFactory',
client_factory: 'HathorClientFactory', pubsub: PubSubManager, manager: 'HathorManager',
ssl: bool) -> None:
from twisted.internet.task import LoopingCall
self.log = logger.new()
self.reactor = reactor
self.my_peer = my_peer
# Factories.
self.server_factory = server_factory
self.server_factory.connections = self
self.client_factory = client_factory
self.client_factory.connections = self
# List of pending connections.
self.connecting_peers = {} # Dict[IStreamClientEndpoint, twisted.internet.defer.Deferred]
# List of peers connected but still not ready to communicate.
self.handshaking_peers = set() # Set[HathorProtocol]
# List of peers connected and ready to communicate.
self.connected_peers = {} # Dict[string (peer.id), HathorProtocol]
# List of peers received from the network.
# We cannot trust their identity before we connect to them.
self.received_peer_storage = PeerStorage() # Dict[string (peer.id), PeerId]
# List of known peers.
self.peer_storage = PeerStorage() # Dict[string (peer.id), PeerId]
self.downloader = Downloader(manager)
# A timer to try to reconnect to the disconnect known peers.
self.lc_reconnect = LoopingCall(self.reconnect_to_all)
self.lc_reconnect.clock = self.reactor
# A timer to try to reconnect to the disconnect known peers.
if settings.ENABLE_PEER_WHITELIST:
self.wl_reconnect = LoopingCall(self.update_whitelist)
self.wl_reconnect.clock = self.reactor
# Pubsub object to publish events
self.pubsub = pubsub
self.ssl = ssl
def test_merge_peer(self):
# Testing peer storage with merge of peers
peer_storage = PeerStorage()
p1 = PeerId()
p2 = PeerId()
p2.id = p1.id
p2.public_key = p1.public_key
p1.public_key = ''
peer_storage.add_or_merge(p1)
self.assertEqual(len(peer_storage), 1)
peer_storage.add_or_merge(p2)
peer = peer_storage[p1.id]
self.assertEqual(peer.id, p1.id)
self.assertEqual(peer.private_key, p1.private_key)
self.assertEqual(peer.public_key, p1.public_key)
self.assertEqual(peer.entrypoints, [])
p3 = PeerId()
p3.entrypoints.append('1')
p3.entrypoints.append('3')
p3.public_key = ''
p4 = PeerId()
p4.public_key = ''
p4.private_key = ''
p4.id = p3.id
p4.entrypoints.append('2')
p4.entrypoints.append('3')
peer_storage.add_or_merge(p4)
self.assertEqual(len(peer_storage), 2)
peer_storage.add_or_merge(p3)
self.assertEqual(len(peer_storage), 2)
peer = peer_storage[p3.id]
self.assertEqual(peer.id, p3.id)
self.assertEqual(peer.private_key, p3.private_key)
self.assertEqual(peer.entrypoints, ['2', '3', '1'])
with self.assertRaises(ValueError):
peer_storage.add(p1)
def __init__(self, reactor: ReactorBase, my_peer: PeerId,
server_factory: 'HathorServerFactory',
client_factory: 'HathorClientFactory', pubsub: PubSubManager,
manager: 'HathorManager', ssl: bool, rng: Random,
whitelist_only: bool, enable_sync_v1: bool,
enable_sync_v2: bool) -> None:
from hathor.p2p.sync_v1_factory import SyncV1Factory
if not (enable_sync_v1 or enable_sync_v2):
raise TypeError(
f'{type(self).__name__}() at least one sync version is required'
)
self.log = logger.new()
self.rng = rng
self.manager = manager
self.reactor = reactor
self.my_peer = my_peer
# Options
self.localhost_only = False
# Factories.
self.server_factory = server_factory
self.server_factory.connections = self
self.client_factory = client_factory
self.client_factory.connections = self
self.max_connections: int = settings.PEER_MAX_CONNECTIONS
# All connections.
self.connections = set()
# List of pending connections.
self.connecting_peers = {}
# List of peers connected but still not ready to communicate.
self.handshaking_peers = set()
# List of peers connected and ready to communicate.
self.connected_peers = {}
# List of peers received from the network.
# We cannot trust their identity before we connect to them.
self.received_peer_storage = PeerStorage()
# List of known peers.
self.peer_storage = PeerStorage() # Dict[string (peer.id), PeerId]
# A timer to try to reconnect to the disconnect known peers.
self.lc_reconnect = LoopingCall(self.reconnect_to_all)
self.lc_reconnect.clock = self.reactor
# A timer to try to reconnect to the disconnect known peers.
if settings.ENABLE_PEER_WHITELIST:
self.wl_reconnect = LoopingCall(self.update_whitelist)
self.wl_reconnect.clock = self.reactor
# Pubsub object to publish events
self.pubsub = pubsub
self.ssl = ssl
# Parameter to explicitly enable whitelist-only mode, when False it will still check the whitelist for sync-v1
self.whitelist_only = whitelist_only
# sync-manager factories
self._sync_factories = {}
if enable_sync_v1:
self._sync_factories[SyncVersion.V1] = SyncV1Factory(self)
if enable_sync_v2:
self._sync_factories[SyncVersion.V2] = SyncV1Factory(self)