p2p

package
v0.22.8-patch-3-fix-co... Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 8, 2021 License: AGPL-3.0 Imports: 57 Imported by: 10

Documentation

Overview

Package libp2p encapsulates the libp2p library

Index

Constants

View Source 
const (
	NoOp communicationMode = iota
	OneToOne
	OneToK
)
View Source 
const (

	// defines maximum message size in publish and multicast modes
	DefaultMaxPubSubMsgSize = 5 * mb // 5 mb

	// defines maximum message size in unicast mode for most messages
	DefaultMaxUnicastMsgSize = 10 * mb // 10 mb

	// defines maximum message size in unicast mode for large messages
	LargeMsgMaxUnicastMsgSize = gb // 1 gb

	// default maximum time to wait for a default unicast request to complete
	// assuming at least a 1mb/sec connection
	DefaultUnicastTimeout = 5 * time.Second

	// maximum time to wait for a unicast request to complete for large message size
	LargeMsgUnicastTimeout = 1000 * time.Second
)
View Source 
const (

	// The common prefix for all Libp2p protocol IDs used for Flow
	// ALL Flow libp2p protocols must start with this prefix
	FlowLibP2PProtocolCommonPrefix = "/flow"

	// A unique Libp2p protocol ID prefix for Flow (https://docs.libp2p.io/concepts/protocols/)
	// All nodes communicate with each other using this protocol id suffixed with the id of the root block
	FlowLibP2POneToOneProtocolIDPrefix = FlowLibP2PProtocolCommonPrefix + "/push/"

	// the Flow Ping protocol prefix
	FlowLibP2PPingProtocolPrefix = FlowLibP2PProtocolCommonPrefix + "/ping/"
)

Flow Libp2p protocols

View Source 
const DefaultCacheSize = 10e6
View Source 
const (

	// Maximum time to wait for a ping reply from a remote node
	PingTimeout = time.Second * 4
)

Variables

View Source 
var DefaultPeerUpdateInterval = 10 * time.Minute

DefaultPeerUpdateInterval is default duration for which the peer manager waits in between attempts to update peer connections

View Source 
var NotEjectedFilter = filter.Not(filter.Ejected)

NotEjectedFilter is an identity filter that, when applied to the identity table at a given snapshot, returns all nodes that we should communicate with over the networking layer.

NOTE: The protocol state includes nodes from the previous/next epoch that should be included in network communication. We omit any nodes that have been ejected.

Functions

func AsServer added in v0.21.0 

func AsServer(enable bool) dht.Option

DHT defaults to ModeAuto which will automatically switch the DHT between Server and Client modes based on whether the node appears to be publicly reachable (e.g. not behind a NAT and with a public IP address). This default tends to make test setups fail (since the test nodes are normally not reachable by the public network), but is useful for improving the stability and performance of live public networks. While we could force all nodes to be DHT Servers, a bunch of nodes otherwise not reachable by most of the network => network partition

func ConnectednessToString 

func ConnectednessToString(connectedness network.Connectedness) (string, bool)

ConnectednessToString reverse translates libp2p network connectedness to string

func CountStream 

func CountStream(host host.Host, targetID peer.ID, protocol core.ProtocolID, dir network.Direction) int

CountStream finds total number of outbound stream to the target id

func DefaultLibP2PHost added in v0.21.0 

func DefaultLibP2PHost(ctx context.Context, address string, key fcrypto.PrivateKey, options ...config.Option) (host.Host,
	error)

DefaultLibP2PHost returns a libp2p host initialized to listen on the given address and using the given private key and customized with options

func DefaultLibP2POptions added in v0.21.0 

func DefaultLibP2POptions(address string, key fcrypto.PrivateKey) ([]config.Option, error)

DefaultLibP2POptions creates and returns the standard LibP2P host options that are used for the Flow Libp2p network

func DefaultPubSub added in v0.21.0 

func DefaultPubSub(ctx context.Context, host host.Host, psOption ...pubsub.Option) (*pubsub.PubSub, error)

DefaultPubSub returns initializes and returns a GossipSub object for the given libp2p host and options

func DefaultValidators added in v0.20.0 

func DefaultValidators(log zerolog.Logger, flowID flow.Identifier) []network.MessageValidator

func DirectionToString 

func DirectionToString(direction network.Direction) (string, bool)

DirectionToString reverse translates libp2p network direction to string

func FindOutboundStream 

func FindOutboundStream(host host.Host, targetID peer.ID, protocol core.ProtocolID) (network.Stream, bool)

FindOutboundStream finds an existing outbound stream to the target id if it exists by querying libp2p

func IPPortFromMultiAddress 

func IPPortFromMultiAddress(addrs ...multiaddr.Multiaddr) (string, string, error)

IPPortFromMultiAddress returns the IP/hostname and the port for the given multi-addresses associated with a libp2p host

func IsUnconvertibleIdentitiesError added in v0.14.0 

func IsUnconvertibleIdentitiesError(err error) bool

IsUnconvertibleIdentitiesError returns whether the given error is an UnconvertibleIdentitiesError error

func MultiAddressStr added in v0.13.0 

func MultiAddressStr(ip, port string) string

MultiAddressStr receives a node ip and port and returns its corresponding Libp2p MultiAddressStr in string format in current implementation IP part of the node address is either an IP or a dns4. https://docs.libp2p.io/concepts/addressing/

func NewDHT added in v0.21.0 

func NewDHT(ctx context.Context, host host.Host, options ...dht.Option) (*dht.IpfsDHT, error)

This produces a new IPFS DHT on the name, see https://github.com/libp2p/go-libp2p-kad-dht/issues/337

func NewUnconvertableIdentitiesError added in v0.14.0 

func NewUnconvertableIdentitiesError(errs map[flow.Identifier]error) error

func PeerAddressInfo added in v0.13.0 

func PeerAddressInfo(identity flow.Identity) (peer.AddrInfo, error)

PeerAddressInfo generates the libp2p peer.AddrInfo for the given Flow.Identity. A node in flow is defined by a flow.Identity while it is defined by a peer.AddrInfo in libp2p. flow.Identity ---> peer.AddrInfo 

|-- Address          --->   |-- []multiaddr.Multiaddr
|-- NetworkPublicKey --->   |-- ID

func WithBootstrapPeers added in v0.21.0 

func WithBootstrapPeers(bootstrapNodes flow.IdentityList) (dht.Option, error)

Types

type ChannelSubscriptionManager 

type ChannelSubscriptionManager struct {
	// contains filtered or unexported fields
}

ChannelSubscriptionManager manages subscriptions of engines running on the node to channels. Each channel should be taken by at most a single engine.

func NewChannelSubscriptionManager 

func NewChannelSubscriptionManager(mw network.Middleware) *ChannelSubscriptionManager

func (*ChannelSubscriptionManager) Channels added in v0.14.0 

func (sm *ChannelSubscriptionManager) Channels() network.ChannelList

Channels returns all the channels registered in this subscription manager.

func (*ChannelSubscriptionManager) GetEngine 

func (sm *ChannelSubscriptionManager) GetEngine(channel network.Channel) (network.Engine, error)

GetEngine returns engine associated with a channel.

func (*ChannelSubscriptionManager) Register 

func (sm *ChannelSubscriptionManager) Register(channel network.Channel, engine network.Engine) error

Register registers an engine on the channel into the subscription manager.

func (*ChannelSubscriptionManager) Unregister 

func (sm *ChannelSubscriptionManager) Unregister(channel network.Channel) error

Unregister removes the engine associated with a channel.

type CloseFunc 

type CloseFunc func(channel network.Channel) error

CloseFunc is a function that unsubscribes the conduit from the channel

type Conduit 

type Conduit struct {
	// contains filtered or unexported fields
}

Conduit is a helper of the overlay layer which functions as an accessor for sending messages within a single engine process. It sends all messages to what can be considered a bus reserved for that specific engine.

func (*Conduit) Close 

func (c *Conduit) Close() error

func (*Conduit) Multicast 

func (c *Conduit) Multicast(event interface{}, num uint, targetIDs ...flow.Identifier) error

Multicast unreliably sends the specified event to the specified number of recipients selected from the specified subset. The recipients are selected randomly from targetIDs

func (*Conduit) Publish 

func (c *Conduit) Publish(event interface{}, targetIDs ...flow.Identifier) error

Publish sends an event to the network layer for unreliable delivery to subscribers of the given event on the network layer. It uses a publish-subscribe layer and can thus not guarantee that the specified recipients received the event.

func (*Conduit) Unicast 

func (c *Conduit) Unicast(event interface{}, targetID flow.Identifier) error

Unicast sends an event in a reliable way to the given recipient. It uses 1-1 direct messaging over the underlying network to deliver the event. It returns an error if the unicast fails.

type ConnGater added in v0.21.0 

type ConnGater struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

ConnGater is the implementation of the libp2p connmgr.ConnectionGater interface It provides node allowlisting by libp2p peer.ID which is derived from the node public networking key

func NewConnGater added in v0.21.0 

func NewConnGater(log zerolog.Logger) *ConnGater

func (*ConnGater) InterceptAccept added in v0.21.0 

func (c *ConnGater) InterceptAccept(cm network.ConnMultiaddrs) bool

InterceptAccept is not used. Currently, allowlisting is only implemented by Peer IDs and not multi-addresses

func (*ConnGater) InterceptAddrDial added in v0.21.0 

func (c *ConnGater) InterceptAddrDial(_ peer.ID, ma multiaddr.Multiaddr) bool

InterceptAddrDial is not used. Currently, allowlisting is only implemented by Peer IDs and not multi-addresses

func (*ConnGater) InterceptPeerDial added in v0.21.0 

func (c *ConnGater) InterceptPeerDial(p peer.ID) bool

InterceptPeerDial - a callback which allows or disallows outbound connection

func (*ConnGater) InterceptSecured added in v0.21.0 

func (c *ConnGater) InterceptSecured(dir network.Direction, p peer.ID, addr network.ConnMultiaddrs) bool

InterceptSecured - a callback executed after the libp2p security handshake. It tests whether to accept or reject an inbound connection based on its peer id.

func (*ConnGater) InterceptUpgraded added in v0.21.0 

func (c *ConnGater) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason)

Decision to continue or drop the connection should have been made before this call

type ConnManager 

type ConnManager struct {
	connmgr.NullConnMgr // a null conn mgr provided by libp2p to allow implementing only the functions needed
	// contains filtered or unexported fields
}

ConnManager provides an implementation of Libp2p's ConnManager interface (https://godoc.org/github.com/libp2p/go-libp2p-core/connmgr#ConnManager) It is called back by libp2p when certain events occur such as opening/closing a stream, opening/closing connection etc. This implementation updates networking metrics when a peer connection is added or removed

func NewConnManager 

func NewConnManager(log zerolog.Logger, metrics module.NetworkMetrics, opts ...ConnManagerOption) *ConnManager

func (*ConnManager) Connected 

func (c *ConnManager) Connected(n network.Network, con network.Conn)

called by libp2p when a connection opened

func (*ConnManager) Disconnected 

func (c *ConnManager) Disconnected(n network.Network, con network.Conn)

called by libp2p when a connection closed

func (*ConnManager) IsProtected added in v0.18.3 

func (c *ConnManager) IsProtected(id peer.ID, _ string) (protected bool)

IsProtected returns true is there is at least one stream setup in progress for the given peer.ID else false

func (*ConnManager) ListenCloseNotifee 

func (c *ConnManager) ListenCloseNotifee(n network.Network, m multiaddr.Multiaddr)

called by libp2p when network stops listening on an addr * This is never called back by libp2p currently and may be a bug on their side

func (*ConnManager) ListenNotifee 

func (c *ConnManager) ListenNotifee(n network.Network, m multiaddr.Multiaddr)

called by libp2p when network starts listening on an addr

func (*ConnManager) Notifee 

func (c *ConnManager) Notifee() network.Notifiee

func (*ConnManager) ProtectPeer added in v0.18.3 

func (c *ConnManager) ProtectPeer(id peer.ID)

ProtectPeer increments the stream setup count for the peer.ID

func (*ConnManager) UnprotectPeer added in v0.18.3 

func (c *ConnManager) UnprotectPeer(id peer.ID)

UnprotectPeer decrements the stream setup count for the peer.ID. If the count reaches zero, the id is removed from the map

type ConnManagerOption added in v0.21.1 

type ConnManagerOption func(*ConnManager)

func TrackUnstakedConnections added in v0.21.1 

func TrackUnstakedConnections(idProvider id.IdentityProvider) ConnManagerOption

type Connector 

type Connector interface {

	// UpdatePeers connects to the given peer.IDs and returns a map of peers which failed. It also
	// disconnects from any other peers with which it may have previously established connection.
	// UpdatePeers implementation should be idempotent such that multiple calls to connect to the same peer should not
	// return an error or create multiple connections
	UpdatePeers(ctx context.Context, peerIDs peer.IDSlice)
}

Connector connects to peer and disconnects from peer using the underlying networking library

type ConnectorOption added in v0.21.1 

type ConnectorOption func(connector *Libp2pConnector)

func WithConnectionPruning added in v0.21.1 

func WithConnectionPruning(enable bool) ConnectorOption

type DefaultLibP2PNodeBuilder added in v0.21.0 

type DefaultLibP2PNodeBuilder struct {
	// contains filtered or unexported fields
}

func (*DefaultLibP2PNodeBuilder) Build added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) Build(ctx context.Context) (*Node, error)

func (*DefaultLibP2PNodeBuilder) SetConnectionGater added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetConnectionGater(connGater *ConnGater) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetConnectionManager added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetConnectionManager(connMngr TagLessConnManager) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetDHTOptions added in v0.21.1 

func (builder *DefaultLibP2PNodeBuilder) SetDHTOptions(opts ...dht.Option) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetLogger added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetLogger(logger zerolog.Logger) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetPingInfoProvider added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetPingInfoProvider(pingInfoProvider PingInfoProvider) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetPubsubOptions added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetPubsubOptions(opts ...PubsubOption) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetResolver added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetResolver(resolver *dns.Resolver) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetRootBlockID added in v0.21.0 

func (builder *DefaultLibP2PNodeBuilder) SetRootBlockID(rootBlockId flow.Identifier) NodeBuilder

func (*DefaultLibP2PNodeBuilder) SetTopicValidation added in v0.22.0 

func (builder *DefaultLibP2PNodeBuilder) SetTopicValidation(enabled bool) NodeBuilder

type FixedTableIdentityTranslator added in v0.21.1 

type FixedTableIdentityTranslator struct {
	// contains filtered or unexported fields
}

FixedTableIdentityTranslator implements an IDTranslator which translates ID's for a fixed list of identities.

func NewFixedTableIdentityTranslator added in v0.21.1 

func NewFixedTableIdentityTranslator(identities flow.IdentityList) (*FixedTableIdentityTranslator, error)

func (*FixedTableIdentityTranslator) GetFlowID added in v0.21.1 

func (t *FixedTableIdentityTranslator) GetFlowID(p peer.ID) (flow.Identifier, error)

func (*FixedTableIdentityTranslator) GetPeerID added in v0.21.1 

func (t *FixedTableIdentityTranslator) GetPeerID(n flow.Identifier) (peer.ID, error)

type HierarchicalIDTranslator added in v0.21.1 

type HierarchicalIDTranslator struct {
	// contains filtered or unexported fields
}

HierarchicalIDTranslator implements an IDTranslator which combines the ID translation capabilities of multiple IDTranslators. When asked to translate an ID, it will iterate through all of the IDTranslators it was given and return the first successful translation.

func NewHierarchicalIDTranslator added in v0.21.1 

func NewHierarchicalIDTranslator(translators ...IDTranslator) *HierarchicalIDTranslator

func (*HierarchicalIDTranslator) GetFlowID added in v0.21.1 

func (t *HierarchicalIDTranslator) GetFlowID(peerID peer.ID) (flow.Identifier, error)

func (*HierarchicalIDTranslator) GetPeerID added in v0.21.1 

func (t *HierarchicalIDTranslator) GetPeerID(flowID flow.Identifier) (peer.ID, error)

type IDTranslator added in v0.21.1 

type IDTranslator interface {
	// GetPeerID returns the peer ID for the given Flow ID
	GetPeerID(flow.Identifier) (peer.ID, error)

	// GetFlowID returns the Flow ID for the given peer ID
	GetFlowID(peer.ID) (flow.Identifier, error)
}

IDTranslator provides an interface for converting from Flow ID's to LibP2P peer ID's and vice versa.

type IdentityProviderIDTranslator added in v0.21.1 

type IdentityProviderIDTranslator struct {
	// contains filtered or unexported fields
}

IdentityProviderIDTranslator implements an IDTranslator which provides ID translation capabilities for an IdentityProvider.

func NewIdentityProviderIDTranslator added in v0.21.1 

func NewIdentityProviderIDTranslator(provider id.IdentityProvider) *IdentityProviderIDTranslator

func (*IdentityProviderIDTranslator) GetFlowID added in v0.21.1 

func (t *IdentityProviderIDTranslator) GetFlowID(p peer.ID) (flow.Identifier, error)

func (*IdentityProviderIDTranslator) GetPeerID added in v0.21.1 

func (t *IdentityProviderIDTranslator) GetPeerID(n flow.Identifier) (peer.ID, error)

type LibP2PFactoryFunc added in v0.13.0 

type LibP2PFactoryFunc func() (*Node, error)

LibP2PFactoryFunc is a factory function type for generating libp2p Node instances.

func DefaultLibP2PNodeFactory added in v0.13.0 

func DefaultLibP2PNodeFactory(ctx context.Context,
	log zerolog.Logger,
	me flow.Identifier,
	address string,
	flowKey fcrypto.PrivateKey,
	rootBlockID flow.Identifier,
	chainID flow.ChainID,
	idProvider id.IdentityProvider,
	maxPubSubMsgSize int,
	metrics module.NetworkMetrics,
	pingInfoProvider PingInfoProvider,
	dnsResolverTTL time.Duration,
	role string) (LibP2PFactoryFunc, error)

DefaultLibP2PNodeFactory returns a LibP2PFactoryFunc which generates the libp2p host initialized with the default options for the host, the pubsub and the ping service.

type Libp2pConnector added in v0.21.1 

type Libp2pConnector struct {
	// contains filtered or unexported fields
}

libp2pConnector is a libp2p based Connector implementation to connect and disconnect from peers

func NewLibp2pConnector added in v0.21.1 

func NewLibp2pConnector(host host.Host, log zerolog.Logger, options ...ConnectorOption) (*Libp2pConnector, error)

func (*Libp2pConnector) UpdatePeers added in v0.21.1 

func (l *Libp2pConnector) UpdatePeers(ctx context.Context, peerIDs peer.IDSlice)

UpdatePeers is the implementation of the Connector.UpdatePeers function. It connects to all of the ids and disconnects from any other connection that the libp2p node might have.

type Middleware 

type Middleware struct {
	sync.Mutex
	// contains filtered or unexported fields
}

Middleware handles the input & output on the direct connections we have to our neighbours on the peer-to-peer network.

func NewMiddleware 

func NewMiddleware(
	log zerolog.Logger,
	libP2PNodeFactory LibP2PFactoryFunc,
	flowID flow.Identifier,
	metrics module.NetworkMetrics,
	rootBlockID flow.Identifier,
	unicastMessageTimeout time.Duration,
	connectionGating bool,
	idTranslator IDTranslator,
	opts ...MiddlewareOption,
) *Middleware

NewMiddleware creates a new middleware instance libP2PNodeFactory is the factory used to create a LibP2PNode flowID is this node's Flow ID metrics is the interface to report network related metrics peerUpdateInterval is the interval when the PeerManager's peer update runs unicastMessageTimeout is the timeout used for unicast messages connectionGating if set to True, restricts this node to only talk to other nodes which are part of the identity list managePeerConnections if set to True, enables the default PeerManager which continuously updates the node's peer connections validators are the set of the different message validators that each inbound messages is passed through

func (*Middleware) GetIPPort 

func (m *Middleware) GetIPPort() (string, string, error)

GetIPPort returns the ip address and port number associated with the middleware

func (*Middleware) IdentifierProvider added in v0.21.1 

func (m *Middleware) IdentifierProvider() id.IdentifierProvider

func (*Middleware) IsConnected 

func (m *Middleware) IsConnected(nodeID flow.Identifier) (bool, error)

IsConnected returns true if this node is connected to the node with id nodeID.

func (*Middleware) Me 

func (m *Middleware) Me() flow.Identifier

Me returns the flow identifier of the this middleware

func (*Middleware) Ping 

func (m *Middleware) Ping(targetID flow.Identifier) (message.PingResponse, time.Duration, error)

Ping pings the target node and returns the ping RTT or an error

func (*Middleware) Publish 

func (m *Middleware) Publish(msg *message.Message, channel network.Channel) error

Publish publishes a message on the channel. It models a distributed broadcast where the message is meant for all or a many nodes subscribing to the channel. It does not guarantee the delivery though, and operates on a best effort.

func (*Middleware) SendDirect 

func (m *Middleware) SendDirect(msg *message.Message, targetID flow.Identifier) error

SendDirect sends msg on a 1-1 direct connection to the target ID. It models a guaranteed delivery asynchronous direct one-to-one connection on the underlying network. No intermediate node on the overlay is utilized as the router.

Dispatch should be used whenever guaranteed delivery to a specific target is required. Otherwise, Publish is a more efficient candidate.

func (*Middleware) Start 

func (m *Middleware) Start(ov network.Overlay) error

Start will start the middleware.

func (*Middleware) Stop 

func (m *Middleware) Stop()

Stop will end the execution of the middleware and wait for it to end.

func (*Middleware) Subscribe 

func (m *Middleware) Subscribe(channel network.Channel) error

Subscribe subscribes the middleware to a channel.

func (*Middleware) Unsubscribe 

func (m *Middleware) Unsubscribe(channel network.Channel) error

Unsubscribe unsubscribes the middleware from a channel.

func (*Middleware) UpdateAllowList 

func (m *Middleware) UpdateAllowList()

UpdateAllowList fetches the most recent identifiers of the nodes from overlay and updates the underlying libp2p node.

func (*Middleware) UpdateNodeAddresses added in v0.21.1 

func (m *Middleware) UpdateNodeAddresses()

type MiddlewareOption added in v0.21.1 

type MiddlewareOption func(*Middleware)

func WithIdentifierProvider added in v0.21.1 

func WithIdentifierProvider(provider id.IdentifierProvider) MiddlewareOption

func WithMessageValidators added in v0.21.1 

func WithMessageValidators(validators ...network.MessageValidator) MiddlewareOption

func WithPeerManager added in v0.21.1 

func WithPeerManager(peerManagerFunc PeerManagerFactoryFunc) MiddlewareOption

type MulticastFunc 

type MulticastFunc func(channel network.Channel, event interface{}, num uint, targetIDs ...flow.Identifier) error

MulticastFunc is a function that unreliably sends the event in the underlying network to randomly chosen subset of nodes from targetIDs

type Network 

type Network struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

Network represents the overlay network of our peer-to-peer network, including the protocols for handshakes, authentication, gossiping and heartbeats.

func NewNetwork 

func NewNetwork(
	log zerolog.Logger,
	codec network.Codec,
	me module.Local,
	mw network.Middleware,
	csize int,
	top network.Topology,
	sm network.SubscriptionManager,
	metrics module.NetworkMetrics,
	identityProvider id.IdentityProvider,
) (*Network, error)

NewNetwork creates a new naive overlay network, using the given middleware to communicate to direct peers, using the given codec for serialization, and using the given state & cache interfaces to track volatile information. csize determines the size of the cache dedicated to keep track of received messages

func (*Network) Done 

func (n *Network) Done() <-chan struct{}

Done returns a channel that will close when shutdown is complete.

func (*Network) Identities added in v0.21.1 

func (n *Network) Identities() flow.IdentityList

func (*Network) Identity 

func (n *Network) Identity(pid peer.ID) (*flow.Identity, bool)

func (*Network) Ready 

func (n *Network) Ready() <-chan struct{}

Ready returns a channel that will close when the network stack is ready.

func (*Network) Receive 

func (n *Network) Receive(nodeID flow.Identifier, msg *message.Message) error

func (*Network) Register 

func (n *Network) Register(channel network.Channel, engine network.Engine) (network.Conduit, error)

Register will register the given engine with the given unique engine engineID, returning a conduit to directly submit messages to the message bus of the engine.

func (*Network) Topology 

func (n *Network) Topology() (flow.IdentityList, error)

Topology returns the identitiess of a uniform subset of nodes in protocol state using the topology provided earlier. Independent invocations of Topology on different nodes collectively constructs a connected network graph.

type Node 

type Node struct {
	sync.Mutex
	// contains filtered or unexported fields
}

Node is a wrapper around the LibP2P host.

func (*Node) AddPeer 

func (n *Node) AddPeer(ctx context.Context, peerInfo peer.AddrInfo) error

AddPeer adds a peer to this node by adding it to this node's peerstore and connecting to it

func (*Node) CreateStream 

func (n *Node) CreateStream(ctx context.Context, peerID peer.ID) (libp2pnet.Stream, error)

CreateStream returns an existing stream connected to the peer if it exists, or creates a new stream with it.

func (*Node) GetIPPort 

func (n *Node) GetIPPort() (string, string, error)

GetIPPort returns the IP and Port the libp2p node is listening on.

func (*Node) Host 

func (n *Node) Host() host.Host

Host returns pointer to host object of node.

func (*Node) IsConnected 

func (n *Node) IsConnected(peerID peer.ID) (bool, error)

IsConnected returns true is address is a direct peer of this node else false

func (*Node) Ping 

func (n *Node) Ping(ctx context.Context, peerID peer.ID) (message.PingResponse, time.Duration, error)

Ping pings a remote node and returns the time it took to ping the remote node if successful or the error

func (*Node) Publish 

func (n *Node) Publish(ctx context.Context, topic flownet.Topic, data []byte) error

Publish publishes the given payload on the topic

func (*Node) RemovePeer 

func (n *Node) RemovePeer(ctx context.Context, peerID peer.ID) error

RemovePeer closes the connection with the peer.

func (*Node) SetFlowProtocolStreamHandler added in v0.17.0 

func (n *Node) SetFlowProtocolStreamHandler(handler libp2pnet.StreamHandler)

SetFlowProtocolStreamHandler sets the stream handler of Flow libp2p Protocol

func (*Node) SetPingStreamHandler added in v0.17.0 

func (n *Node) SetPingStreamHandler(handler libp2pnet.StreamHandler)

SetPingStreamHandler sets the stream handler for the Flow Ping protocol.

func (*Node) Stop 

func (n *Node) Stop() (chan struct{}, error)

Stop terminates the libp2p node.

func (*Node) Subscribe 

func (n *Node) Subscribe(ctx context.Context, topic flownet.Topic, validators ...validator.MessageValidator) (*pubsub.Subscription, error)

Subscribe subscribes the node to the given topic and returns the subscription Currently only one subscriber is allowed per topic. NOTE: A node will receive its own published messages.

func (*Node) UnSubscribe 

func (n *Node) UnSubscribe(topic flownet.Topic) error

UnSubscribe cancels the subscriber and closes the topic.

func (*Node) UpdateAllowList added in v0.13.0 

func (n *Node) UpdateAllowList(peers peer.IDSlice)

UpdateAllowList allows the peer allow list to be updated.

type NodeBuilder added in v0.21.0 

type NodeBuilder interface {
	SetRootBlockID(flow.Identifier) NodeBuilder
	SetConnectionManager(TagLessConnManager) NodeBuilder
	SetConnectionGater(*ConnGater) NodeBuilder
	SetPubsubOptions(...PubsubOption) NodeBuilder
	SetPingInfoProvider(PingInfoProvider) NodeBuilder
	SetDHTOptions(...dht.Option) NodeBuilder
	SetTopicValidation(bool) NodeBuilder
	SetLogger(zerolog.Logger) NodeBuilder
	SetResolver(*dns.Resolver) NodeBuilder
	Build(context.Context) (*Node, error)
}

func NewDefaultLibP2PNodeBuilder added in v0.21.0 

func NewDefaultLibP2PNodeBuilder(id flow.Identifier, address string, flowKey fcrypto.PrivateKey) NodeBuilder

type Option added in v0.18.0 

type Option func(*PeerManager)

Option represents an option for the peer manager.

func WithInterval added in v0.18.0 

func WithInterval(period time.Duration) Option

type PeerManager 

type PeerManager struct {
	// contains filtered or unexported fields
}

PeerManager adds and removes connections to peers periodically and on request

func NewPeerManager 

func NewPeerManager(logger zerolog.Logger, peersProvider PeersProvider,
	connector Connector, options ...Option) *PeerManager

NewPeerManager creates a new peer manager which calls the peersProvider callback to get a list of peers to connect to and it uses the connector to actually connect or disconnect from peers.

func (*PeerManager) Done 

func (pm *PeerManager) Done() <-chan struct{}

func (*PeerManager) Ready 

func (pm *PeerManager) Ready() <-chan struct{}

Ready kicks off the ambient periodic connection updates.

func (*PeerManager) RequestPeerUpdate 

func (pm *PeerManager) RequestPeerUpdate()

RequestPeerUpdate requests an update to the peer connections of this node. If a peer update has already been requested (either as a periodic request or an on-demand request) and is outstanding, then this call is a no-op.

type PeerManagerFactoryFunc added in v0.21.1 

type PeerManagerFactoryFunc func(host host.Host, peersProvider PeersProvider, logger zerolog.Logger) (*PeerManager, error)

PeerManagerFactoryFunc is a factory function type for generating a PeerManager instance using the given host, peersProvider and logger

func PeerManagerFactory added in v0.21.1 

func PeerManagerFactory(peerManagerOptions []Option, connectorOptions ...ConnectorOption) PeerManagerFactoryFunc

PeerManagerFactory generates a PeerManagerFunc that produces the default PeerManager with the given peer manager options and that uses the LibP2PConnector with the given LibP2P connector options

type PeersProvider added in v0.21.1 

type PeersProvider func() (peer.IDSlice, error)

type PeerstoreIdentifierProvider added in v0.21.1 

type PeerstoreIdentifierProvider struct {
	// contains filtered or unexported fields
}

PeerstoreIdentifierProvider implements an IdentifierProvider which provides the identifiers of the peers present in the given LibP2P host's peerstore.

func NewPeerstoreIdentifierProvider added in v0.21.1 

func NewPeerstoreIdentifierProvider(logger zerolog.Logger, host host.Host, idTranslator IDTranslator) *PeerstoreIdentifierProvider

func (*PeerstoreIdentifierProvider) Identifiers added in v0.21.1 

func (p *PeerstoreIdentifierProvider) Identifiers() flow.IdentifierList

type PingInfoProvider added in v0.17.0 

type PingInfoProvider interface {
	SoftwareVersion() string
	SealedBlockHeight() uint64
}

PingInfoProvider is the interface used by the PingService to respond to incoming PingRequest with a PingResponse populated with the necessary details

type PingInfoProviderImpl added in v0.17.0 

type PingInfoProviderImpl struct {
	SoftwareVersionFun   func() string
	SealedBlockHeightFun func() (uint64, error)
}

func (PingInfoProviderImpl) SealedBlockHeight added in v0.17.1 

func (p PingInfoProviderImpl) SealedBlockHeight() uint64

func (PingInfoProviderImpl) SoftwareVersion added in v0.17.0 

func (p PingInfoProviderImpl) SoftwareVersion() string

type PingService added in v0.17.0 

type PingService struct {
	// contains filtered or unexported fields
}

PingService handles the outbound and inbound ping requests and response

func NewPingService added in v0.17.0 

func NewPingService(h host.Host, pingProtocolID protocol.ID, pingInfoProvider PingInfoProvider, logger zerolog.Logger) *PingService

func (*PingService) Ping added in v0.17.0 

func (ps *PingService) Ping(ctx context.Context, p peer.ID) (message.PingResponse, time.Duration, error)

Ping sends a Ping request to the remote node and returns the response, rtt and error if any.

func (*PingService) PingHandler added in v0.17.0 

func (ps *PingService) PingHandler(s network.Stream)

PingHandler receives the inbound stream for Flow ping protocol and respond back with the PingResponse message

type ProtocolStateIDCache added in v0.21.1 

type ProtocolStateIDCache struct {
	events.Noop
	// contains filtered or unexported fields
}

ProtocolStateIDCache implements an IdentityProvider and IDTranslator for the set of staked Flow network participants as according to the given `protocol.State`.

func NewProtocolStateIDCache added in v0.21.1 

func NewProtocolStateIDCache(
	logger zerolog.Logger,
	state protocol.State,
	eventDistributer *events.Distributor,
) (*ProtocolStateIDCache, error)

func (*ProtocolStateIDCache) ByNodeID added in v0.21.1 

func (p *ProtocolStateIDCache) ByNodeID(flowID flow.Identifier) (*flow.Identity, bool)

func (*ProtocolStateIDCache) ByPeerID added in v0.21.1 

func (p *ProtocolStateIDCache) ByPeerID(peerID peer.ID) (*flow.Identity, bool)

func (*ProtocolStateIDCache) EpochCommittedPhaseStarted added in v0.21.1 

func (p *ProtocolStateIDCache) EpochCommittedPhaseStarted(currentEpochCounter uint64, header *flow.Header)

func (*ProtocolStateIDCache) EpochSetupPhaseStarted added in v0.21.1 

func (p *ProtocolStateIDCache) EpochSetupPhaseStarted(currentEpochCounter uint64, header *flow.Header)

func (*ProtocolStateIDCache) EpochTransition added in v0.21.1 

func (p *ProtocolStateIDCache) EpochTransition(newEpochCounter uint64, header *flow.Header)

func (*ProtocolStateIDCache) GetFlowID added in v0.21.1 

func (p *ProtocolStateIDCache) GetFlowID(peerID peer.ID) (fid flow.Identifier, err error)

func (*ProtocolStateIDCache) GetPeerID added in v0.21.1 

func (p *ProtocolStateIDCache) GetPeerID(flowID flow.Identifier) (pid peer.ID, err error)

func (*ProtocolStateIDCache) Identities added in v0.21.1 

func (p *ProtocolStateIDCache) Identities(filter flow.IdentityFilter) flow.IdentityList

type PublishFunc 

type PublishFunc func(channel network.Channel, event interface{}, targetIDs ...flow.Identifier) error

PublishFunc is a function that broadcasts the specified event to all participants on the given channel.

type PubsubOption added in v0.21.0 

type PubsubOption func(ctx context.Context, host host.Host) (pubsub.Option, error)

PubsubOption generates a libp2p pubsub.Option from the given context and host

func DefaultPubsubOptions added in v0.21.0 

func DefaultPubsubOptions(maxPubSubMsgSize int) []PubsubOption

func WithDHTDiscovery added in v0.21.0 

func WithDHTDiscovery(kdht *dht.IpfsDHT) PubsubOption

type RcvCache 

type RcvCache struct {
	// contains filtered or unexported fields
}

RcvCache implements an LRU cache of the received eventIDs that delivered to their engines

type RcvCacheEntry 

type RcvCacheEntry struct {
	// contains filtered or unexported fields
}

RcvCacheEntry represents an entry for the RcvCache

type RoleBasedFilter added in v0.22.4 

type RoleBasedFilter struct {
	// contains filtered or unexported fields
}

RoleBasedFilter implements a subscription filter that filters subscriptions based on a node's role.

func NewRoleBasedFilter added in v0.22.4 

func NewRoleBasedFilter(pid peer.ID, rootBlockID flow.Identifier, idProvider id.IdentityProvider) *RoleBasedFilter

func (*RoleBasedFilter) CanSubscribe added in v0.22.4 

func (f *RoleBasedFilter) CanSubscribe(topic string) bool

func (*RoleBasedFilter) FilterIncomingSubscriptions added in v0.22.4 

func (f *RoleBasedFilter) FilterIncomingSubscriptions(from peer.ID, opts []*pb.RPC_SubOpts) ([]*pb.RPC_SubOpts, error)

type TagLessConnManager added in v0.21.0 

type TagLessConnManager interface {
	connmgr.ConnManager
	// ProtectPeer increments the stream setup count for the peer.ID
	ProtectPeer(id peer.ID)
	// UnprotectPeer decrements the stream setup count for the peer.ID.
	// If the count reaches zero, the id is removed from the map
	UnprotectPeer(id peer.ID)
}

TagLessConnManager is a companion interface to libp2p-core.connmgr.ConnManager which implements a (simplified) tagless variant of the Protect / Unprotect logic

type UnconvertibleIdentitiesError added in v0.14.0 

type UnconvertibleIdentitiesError struct {
	// contains filtered or unexported fields
}

UnconvertibleIdentitiesError is an error which reports all the flow.Identifiers that could not be converted to peer.AddrInfo

func (UnconvertibleIdentitiesError) Error added in v0.14.0 

func (e UnconvertibleIdentitiesError) Error() string

type UnicastFunc 

type UnicastFunc func(channel network.Channel, event interface{}, targetID flow.Identifier) error

UnicastFunc is a function that reliably sends the event via reliable 1-1 direct connection in the underlying network to the target ID.

type UnstakedNetworkIDTranslator added in v0.21.1 

type UnstakedNetworkIDTranslator struct{}

UnstakedNetworkIDTranslator implements an IDTranslator which translates IDs for peers on the unstaked network. On the unstaked network, a Flow ID is derived from a peer ID by extracting the public key from the peer ID, dropping the first byte (parity byte), and using the remaining 32 bytes as the Flow ID. Network keys for unstaked nodes must be generated using the Secp256k1 curve, and must be positive. It is assumed that these requirements are enforced during key generation, and any peer ID's which don't follow these conventions are considered invalid.

func NewUnstakedNetworkIDTranslator added in v0.21.1 

func NewUnstakedNetworkIDTranslator() *UnstakedNetworkIDTranslator

func (*UnstakedNetworkIDTranslator) GetFlowID added in v0.21.1 

func (t *UnstakedNetworkIDTranslator) GetFlowID(peerID peer.ID) (flow.Identifier, error)

func (*UnstakedNetworkIDTranslator) GetPeerID added in v0.21.1 

func (t *UnstakedNetworkIDTranslator) GetPeerID(flowID flow.Identifier) (peer.ID, error)

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.