def test_peer_info_basic():
store = PeerStore()
store.add_addr("peer", "/foo", 10)
info = store.peer_info("peer")
assert info.peer_id == "peer"
assert info.addrs == ["/foo"]
def test_peers():
store = PeerStore()
store.add_protocols("peer1", [])
store.put("peer2", "key", "val")
store.add_addr("peer3", "/foo", 10)
assert set(store.peers()) == set(["peer1", "peer2", "peer3"])
def test_peers_with_addrs():
store = PeerStore()
store.add_addrs("peer1", [], 10)
store.add_addrs("peer2", ["/foo"], 10)
store.add_addrs("peer3", ["/bar"], 10)
assert set(store.peers_with_addrs()) == set(["peer2", "peer3"])
store.clear_addrs("peer2")
assert set(store.peers_with_addrs()) == set(["peer3"])
def test_put_get_two_peers():
store = PeerStore()
store.put("peer1", "key1", "val1")
store.put("peer2", "key1", "val1 prime")
assert store.get("peer1", "key1") == "val1"
assert store.get("peer2", "key1") == "val1 prime"
# Try update
store.put("peer2", "key1", "new val1")
assert store.get("peer1", "key1") == "val1"
assert store.get("peer2", "key1") == "new val1"
def __init__(
self,
key_pair: KeyPair,
peer_id: PeerID,
peer_updater: PeerUpdater,
status_provider: StatusProvider,
finalized_root_provider: Callable[[Epoch], Root],
block_provider_by_slot: BlockProviderBySlot,
block_provider_by_root: BlockProviderByRoot,
metadata_provider: MetadataProvider,
fork_digest_provider: ForkDigestProvider,
eth2_config: Eth2Config,
) -> None:
peer_store = PeerStore()
peer_store.add_key_pair(peer_id, key_pair)
muxer_transports_by_protocol = {MPLEX_PROTOCOL_ID: Mplex}
noise_key = ed25519.create_new_key_pair()
security_transports_by_protocol = {
TProtocol(secio.ID):
secio.Transport(key_pair),
TProtocol(noise.PROTOCOL_ID):
noise.Transport(key_pair, noise_key.private_key)
}
upgrader = TransportUpgrader(security_transports_by_protocol,
muxer_transports_by_protocol)
transport = TCP()
swarm = Swarm(peer_id, peer_store, upgrader, transport)
BasicHost.__init__(self, swarm)
self._peer_updater = peer_updater
self._status_provider = status_provider
self._finalized_root_provider_by_epoch = finalized_root_provider
self._block_provider_by_slot = block_provider_by_slot
self._block_provider_by_root = block_provider_by_root
self._metadata_provider = metadata_provider
self._request_responder = RequestResponder(
self._peer_updater,
self._status_provider,
self._block_provider_by_slot,
self._block_provider_by_root,
self._metadata_provider,
)
self._install_req_resp_protocols()
self._gossiper = Gossiper(fork_digest_provider, self)
self._peers: Set[PeerID] = set()
def test_add_addrs_multiple():
store = PeerStore()
store.add_addrs("peer1", ["/foo1", "/bar1"], 10)
store.add_addrs("peer2", ["/foo2"], 10)
assert store.addrs("peer1") == ["/foo1", "/bar1"]
assert store.addrs("peer2") == ["/foo2"]
def test_add_get_protocols_basic():
store = PeerStore()
store.add_protocols("peer1", ["p1", "p2"])
store.add_protocols("peer2", ["p3"])
assert set(store.get_protocols("peer1")) == set(["p1", "p2"])
assert set(store.get_protocols("peer2")) == set(["p3"])
def test_add_addr_single():
store = PeerStore()
store.add_addr("peer1", "/foo", 10)
store.add_addr("peer1", "/bar", 10)
store.add_addr("peer2", "/baz", 10)
assert store.addrs("peer1") == ["/foo", "/bar"]
assert store.addrs("peer2") == ["/baz"]
def test_put_get_update():
store = PeerStore()
store.put("peer", "key1", "val1")
store.put("peer", "key2", "val2")
store.put("peer", "key2", "new val2")
assert store.get("peer", "key1") == "val1"
assert store.get("peer", "key2") == "new val2"
def initialize_default_swarm(
key_pair: KeyPair,
id_opt: ID = None,
transport_opt: Sequence[str] = None,
muxer_opt: TMuxerOptions = None,
sec_opt: TSecurityOptions = None,
peerstore_opt: IPeerStore = None,
) -> Swarm:
"""
initialize swarm when no swarm is passed in.
:param id_opt: optional id for host
:param transport_opt: optional choice of transport upgrade
:param muxer_opt: optional choice of stream muxer
:param sec_opt: optional choice of security upgrade
:param peerstore_opt: optional peerstore
:return: return a default swarm instance
"""
if not id_opt:
id_opt = generate_peer_id_from(key_pair)
# TODO: Parse `transport_opt` to determine transport
transport = TCP()
muxer_transports_by_protocol = muxer_opt or {MPLEX_PROTOCOL_ID: Mplex}
security_transports_by_protocol = sec_opt or {
TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair),
TProtocol(secio.ID): secio.Transport(key_pair),
}
upgrader = TransportUpgrader(security_transports_by_protocol,
muxer_transports_by_protocol)
peerstore = peerstore_opt or PeerStore()
# Store our key pair in peerstore
peerstore.add_key_pair(id_opt, key_pair)
# TODO: Initialize discovery if not presented
return Swarm(id_opt, peerstore, upgrader, transport)
def new_swarm(
key_pair: KeyPair = None,
muxer_opt: TMuxerOptions = None,
sec_opt: TSecurityOptions = None,
peerstore_opt: IPeerStore = None,
) -> INetworkService:
"""
Create a swarm instance based on the parameters.
:param key_pair: optional choice of the ``KeyPair``
:param muxer_opt: optional choice of stream muxer
:param sec_opt: optional choice of security upgrade
:param peerstore_opt: optional peerstore
:return: return a default swarm instance
"""
if key_pair is None:
key_pair = generate_new_rsa_identity()
id_opt = generate_peer_id_from(key_pair)
# TODO: Parse `listen_addrs` to determine transport
transport = TCP()
muxer_transports_by_protocol = muxer_opt or {MPLEX_PROTOCOL_ID: Mplex}
security_transports_by_protocol = sec_opt or {
TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair),
TProtocol(secio.ID): secio.Transport(key_pair),
}
upgrader = TransportUpgrader(security_transports_by_protocol,
muxer_transports_by_protocol)
peerstore = peerstore_opt or PeerStore()
# Store our key pair in peerstore
peerstore.add_key_pair(id_opt, key_pair)
return Swarm(id_opt, peerstore, upgrader, transport)
def test_peer_info_empty():
store = PeerStore()
info = store.peer_info("peer")
assert not info
def test_set_protocols():
store = PeerStore()
store.add_protocols("peer1", ["p1", "p2"])
store.add_protocols("peer2", ["p3"])
store.set_protocols("peer1", ["p4"])
store.set_protocols("peer2", [])
assert set(store.get_protocols("peer1")) == set(["p4"])
assert set(store.get_protocols("peer2")) == set([])
def initialize_peerstore_with_our_keypair(self_id: ID,
key_pair: KeyPair) -> PeerStore:
peer_store = PeerStore()
peer_store.add_key_pair(self_id, key_pair)
return peer_store
def test_addrs_empty():
with pytest.raises(PeerStoreError):
store = PeerStore()
val = store.addrs("peer")
assert not val
def test_put_get_simple():
store = PeerStore()
store.put("peer", "key", "val")
assert store.get("peer", "key") == "val"
def test_clear_addrs():
store = PeerStore()
store.add_addrs("peer1", ["/foo1", "/bar1"], 10)
store.add_addrs("peer2", ["/foo2"], 10)
store.clear_addrs("peer1")
assert store.addrs("peer1") == []
assert store.addrs("peer2") == ["/foo2"]
store.add_addrs("peer1", ["/foo1", "/bar1"], 10)
assert store.addrs("peer1") == ["/foo1", "/bar1"]
def test_peer_info_empty():
store = PeerStore()
with pytest.raises(PeerStoreError):
store.peer_info("peer")
def test_get_empty():
with pytest.raises(PeerStoreError):
store = PeerStore()
val = store.get("peer", "key")
assert not val
