libp2p.network package

Subpackages

• libp2p.network.connection package
  • Submodules
  • libp2p.network.connection.exceptions module
  • libp2p.network.connection.net_connection_interface module
  • libp2p.network.connection.raw_connection module
  • libp2p.network.connection.raw_connection_interface module
  • libp2p.network.connection.swarm_connection module
  • Module contents
• libp2p.network.stream package
  • Submodules
  • libp2p.network.stream.exceptions module
  • libp2p.network.stream.net_stream module
  • libp2p.network.stream.net_stream_interface module
  • Module contents

Submodules

libp2p.network.exceptions module

exception libp2p.network.exceptions.SwarmException

Bases: libp2p.exceptions.BaseLibp2pError

libp2p.network.network_interface module

class libp2p.network.network_interface.INetwork

Bases: abc.ABC

abstract async close() → None

abstract async close_peer(peer_id: libp2p.peer.id.ID) → None

connections: Dict[ID, INetConn] = None

abstract async dial_peer(peer_id: libp2p.peer.id.ID) → libp2p.network.connection.net_connection_interface.INetConn

dial_peer try to create a connection to peer_id.

Parameters

peer_id – peer if we want to dial

Raises

SwarmException – raised when an error occurs

Returns

muxed connection

abstract get_peer_id() → libp2p.peer.id.ID

Returns

the peer id

abstract async listen(*multiaddrs: Sequence[multiaddr.multiaddr.Multiaddr]) → bool

Parameters

multiaddrs – one or many multiaddrs to start listening on

Returns

True if at least one success

listeners: Dict[str, IListener] = None

abstract async new_stream(peer_id: libp2p.peer.id.ID) → libp2p.network.stream.net_stream_interface.INetStream

Parameters

• peer_id – peer_id of destination

• protocol_ids – available protocol ids to use for stream

Returns

net stream instance

peerstore: IPeerStore = None

abstract register_notifee(notifee: INotifee) → None

Parameters

notifee – object implementing Notifee interface

Returns

true if notifee registered successfully, false otherwise

abstract set_stream_handler(stream_handler: Callable[[INetStream], Awaitable[None]]) → None

Set the stream handler for all incoming streams.

class libp2p.network.network_interface.INetworkService

Bases: libp2p.network.network_interface.INetwork, async_service.abc.ServiceAPI

connections = None

listeners = None

peerstore = None

libp2p.network.notifee_interface module

class libp2p.network.notifee_interface.INotifee

Bases: abc.ABC

abstract async closed_stream(network: INetwork, stream: libp2p.network.stream.net_stream_interface.INetStream) → None

Parameters

• network – network the stream was closed on

• stream – stream that was closed

abstract async connected(network: INetwork, conn: libp2p.network.connection.net_connection_interface.INetConn) → None

Parameters

• network – network the connection was opened on

• conn – connection that was opened

abstract async disconnected(network: INetwork, conn: libp2p.network.connection.net_connection_interface.INetConn) → None

Parameters

• network – network the connection was closed on

• conn – connection that was closed

abstract async listen(network: INetwork, multiaddr: multiaddr.multiaddr.Multiaddr) → None

Parameters

• network – network the listener is listening on

• multiaddr – multiaddress listener is listening on

abstract async listen_close(network: INetwork, multiaddr: multiaddr.multiaddr.Multiaddr) → None

Parameters

• network – network the connection was opened on

• multiaddr – multiaddress listener is no longer listening on

abstract async opened_stream(network: INetwork, stream: libp2p.network.stream.net_stream_interface.INetStream) → None

Parameters

• network – network the stream was opened on

• stream – stream that was opened

libp2p.network.swarm module

class libp2p.network.swarm.Swarm(peer_id: libp2p.peer.id.ID, peerstore: libp2p.peer.peerstore_interface.IPeerStore, upgrader: libp2p.transport.upgrader.TransportUpgrader, transport: libp2p.transport.transport_interface.ITransport)

Bases: async_service.base.Service, libp2p.network.network_interface.INetworkService

async add_conn(muxed_conn: libp2p.stream_muxer.abc.IMuxedConn) → libp2p.network.connection.swarm_connection.SwarmConn

Add a IMuxedConn to Swarm as a SwarmConn, notify “connected”, and start to monitor the connection for its new streams and disconnection.

async close() → None

async close_peer(peer_id: libp2p.peer.id.ID) → None

common_stream_handler: StreamHandlerFn = None

connections: Dict[ID, INetConn] = None

async dial_addr(addr: multiaddr.multiaddr.Multiaddr, peer_id: libp2p.peer.id.ID) → libp2p.network.connection.net_connection_interface.INetConn

dial_addr try to create a connection to peer_id with addr.

Parameters

• addr – the address we want to connect with

• peer_id – the peer we want to connect to

Raises

SwarmException – raised when an error occurs

Returns

network connection

async dial_peer(peer_id: libp2p.peer.id.ID) → libp2p.network.connection.net_connection_interface.INetConn

dial_peer try to create a connection to peer_id.

Parameters

peer_id – peer if we want to dial

Raises

SwarmException – raised when an error occurs

Returns

muxed connection

event_listener_nursery_created: trio.Event = None

get_peer_id() → libp2p.peer.id.ID

Returns

the peer id

async listen(*multiaddrs: multiaddr.multiaddr.Multiaddr) → bool

Parameters

multiaddrs – one or many multiaddrs to start listening on

Returns

true if at least one success

For each multiaddr

• Check if a listener for multiaddr exists already

• If listener already exists, continue

• Otherwise:

  • Capture multiaddr in conn handler

  • Have conn handler delegate to stream handler

  • Call listener listen with the multiaddr

  • Map multiaddr to listener

listener_nursery: Optional[trio.Nursery] = None

listeners: Dict[str, IListener] = None

async new_stream(peer_id: libp2p.peer.id.ID) → libp2p.network.stream.net_stream_interface.INetStream

Parameters

peer_id – peer_id of destination

Raises

SwarmException – raised when an error occurs

Returns

net stream instance

notifees: List[INotifee] = None

async notify_closed_stream(stream: libp2p.network.stream.net_stream_interface.INetStream) → None

async notify_connected(conn: libp2p.network.connection.net_connection_interface.INetConn) → None

async notify_disconnected(conn: libp2p.network.connection.net_connection_interface.INetConn) → None

async notify_listen(multiaddr: multiaddr.multiaddr.Multiaddr) → None

async notify_listen_close(multiaddr: multiaddr.multiaddr.Multiaddr) → None

async notify_opened_stream(stream: libp2p.network.stream.net_stream_interface.INetStream) → None

peerstore: IPeerStore = None

register_notifee(notifee: libp2p.network.notifee_interface.INotifee) → None

Parameters

notifee – object implementing Notifee interface

Returns

true if notifee registered successfully, false otherwise

remove_conn(swarm_conn: libp2p.network.connection.swarm_connection.SwarmConn) → None

Simply remove the connection from Swarm’s records, without closing the connection.

async run() → None

Primary entry point for all service logic.

Note

This method should not be directly invoked by user code.

Services may be run using the following approaches.

self_id: ID = None

set_stream_handler(stream_handler: Callable[[INetStream], Awaitable[None]]) → None

Set the stream handler for all incoming streams.

transport: ITransport = None

upgrader: TransportUpgrader = None

libp2p.network.swarm.create_default_stream_handler(network: libp2p.network.network_interface.INetworkService) → Callable[[libp2p.network.stream.net_stream_interface.INetStream], Awaitable[None]]

Module contents