async def test_single_insecure_security_transport_succeeds():
transports_for_initiator = {"foo": InsecureTransport(initiator_key_pair)}
transports_for_noninitiator = {"foo": InsecureTransport(noninitiator_key_pair)}
def assertion_func(conn):
assert isinstance(conn, InsecureSession)
await perform_simple_test(
assertion_func, transports_for_initiator, transports_for_noninitiator
)
def security_transport_factory(
is_secure: bool, key_pair: KeyPair
) -> Dict[TProtocol, BaseSecureTransport]:
if not is_secure:
return {PLAINTEXT_PROTOCOL_ID: InsecureTransport(key_pair)}
else:
return {secio.ID: secio.Transport(key_pair)}
def __init__(
self,
key_pair: KeyPair,
listen_ip: str,
listen_port: int,
chain: BaseBeaconChain,
security_protocol_ops: Dict[TProtocol, BaseSecureTransport] = None,
muxer_protocol_ops: Dict[TProtocol, IMuxedConn] = None,
gossipsub_params: Optional[GossipsubParams] = None,
cancel_token: CancelToken = None,
bootstrap_nodes: Tuple[Multiaddr, ...] = None,
preferred_nodes: Tuple[Multiaddr, ...] = None) -> None:
super().__init__(cancel_token)
self.listen_ip = listen_ip
self.listen_port = listen_port
self.key_pair = key_pair
self.bootstrap_nodes = bootstrap_nodes
self.preferred_nodes = preferred_nodes
# TODO: Add key and peer_id to the peerstore
if security_protocol_ops is None:
security_protocol_ops = {
PLAINTEXT_PROTOCOL_ID: InsecureTransport(key_pair)
}
if muxer_protocol_ops is None:
muxer_protocol_ops = {MPLEX_PROTOCOL_ID: Mplex}
network: INetwork = initialize_default_swarm(
key_pair=key_pair,
transport_opt=[self.listen_maddr],
muxer_opt=muxer_protocol_ops,
sec_opt=security_protocol_ops,
peerstore_opt=None, # let the function initialize it
disc_opt=None, # no routing required here
)
self.host = BasicHost(network=network, router=None)
if gossipsub_params is None:
gossipsub_params = GossipsubParams()
gossipsub_router = GossipSub(
protocols=[GOSSIPSUB_PROTOCOL_ID],
degree=gossipsub_params.DEGREE,
degree_low=gossipsub_params.DEGREE_LOW,
degree_high=gossipsub_params.DEGREE_HIGH,
time_to_live=gossipsub_params.FANOUT_TTL,
gossip_window=gossipsub_params.GOSSIP_WINDOW,
gossip_history=gossipsub_params.GOSSIP_HISTORY,
heartbeat_interval=gossipsub_params.HEARTBEAT_INTERVAL,
)
self.pubsub = Pubsub(
host=self.host,
router=gossipsub_router,
my_id=self.peer_id,
)
self.chain = chain
self.handshaked_peers = PeerPool()
self.run_task(self.start())
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 plaintext_transport_factory(key_pair: KeyPair) -> ISecureTransport:
return InsecureTransport(key_pair)