p2p

package
v0.31.2-rc0 Latest Latest
Warning

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

 Go to latest Published: Mar 30, 2019 License: Apache-2.0 Imports: 27 Imported by: 0

README ¶

p2p

The p2p package provides an abstraction around peer-to-peer communication.

Docs:

  • Connection for details on how connections and multiplexing work
  • Peer for details on peer ID, handshakes, and peer exchange
  • Node for details about different types of nodes and how they should work
  • Pex for details on peer discovery and exchange
  • Config for details on some config option

Documentation ¶

Index ¶

Constants ¶

View Source 
const IDByteLength = crypto.AddressSize

IDByteLength is the length of a crypto.Address. Currently only 20. TODO: support other length addresses ?

View Source 
const (
	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
	// package.
	MetricsSubsystem = "p2p"
)
View Source 
const TEST_HOST = "localhost"

Variables ¶

This section is empty.

Functions ¶

func AddPeerToSwitch ¶ 

func AddPeerToSwitch(sw *Switch, peer Peer)

func Connect2Switches ¶ 

func Connect2Switches(switches []*Switch, i, j int)

Connect2Switches will connect switches i and j via net.Pipe(). Blocks until a connection is established. NOTE: caller ensures i and j are within bounds.

func CreateRandomPeer ¶ 

func CreateRandomPeer(outbound bool) *peer

func FuzzConn ¶ 

func FuzzConn(conn net.Conn) net.Conn

FuzzConn creates a new FuzzedConnection. Fuzzing starts immediately.

func FuzzConnAfter ¶ 

func FuzzConnAfter(conn net.Conn, d time.Duration) net.Conn

FuzzConnAfter creates a new FuzzedConnection. Fuzzing starts when the duration elapses.

func FuzzConnAfterFromConfig ¶ 

func FuzzConnAfterFromConfig(
	conn net.Conn,
	d time.Duration,
	config *config.FuzzConnConfig,
) net.Conn

FuzzConnAfterFromConfig creates a new FuzzedConnection from a config. Fuzzing starts when the duration elapses.

func FuzzConnFromConfig ¶ 

func FuzzConnFromConfig(conn net.Conn, config *config.FuzzConnConfig) net.Conn

FuzzConnFromConfig creates a new FuzzedConnection from a config. Fuzzing starts immediately.

func IDAddressString ¶ 

func IDAddressString(id ID, protocolHostPort string) string

IDAddressString returns id@hostPort. It strips the leading protocol from protocolHostPort if it exists.

func MConnConfig ¶ 

func MConnConfig(cfg *config.P2PConfig) conn.MConnConfig

MConnConfig returns an MConnConfig with fields updated from the P2PConfig.

func MakePoWTarget ¶ 

func MakePoWTarget(difficulty, targetBits uint) []byte

MakePoWTarget returns the big-endian encoding of 2^(targetBits - difficulty) - 1. It can be used as a Proof of Work target. NOTE: targetBits must be a multiple of 8 and difficulty must be less than targetBits.

func MaxNodeInfoSize ¶ 

func MaxNodeInfoSize() int

Max size of the NodeInfo struct

func NewConnSet ¶ 

func NewConnSet() *connSet

NewConnSet returns a ConnSet implementation.

func StartSwitches ¶ 

func StartSwitches(switches []*Switch) error

StartSwitches calls sw.Start() for each given switch. It returns the first encountered error.

Types ¶

type AddrBook ¶ 

type AddrBook interface {
	AddAddress(addr *NetAddress, src *NetAddress) error
	AddOurAddress(*NetAddress)
	OurAddress(*NetAddress) bool
	MarkGood(*NetAddress)
	RemoveAddress(*NetAddress)
	HasAddress(*NetAddress) bool
	Save()
}

An AddrBook represents an address book from the pex package, which is used to store peer addresses.

type BaseReactor ¶ 

type BaseReactor struct {
	cmn.BaseService // Provides Start, Stop, .Quit
	Switch          *Switch
}

func NewBaseReactor ¶ 

func NewBaseReactor(name string, impl Reactor) *BaseReactor

func (*BaseReactor) AddPeer ¶ 

func (*BaseReactor) AddPeer(peer Peer)

func (*BaseReactor) GetChannels ¶ 

func (*BaseReactor) GetChannels() []*conn.ChannelDescriptor

func (*BaseReactor) Receive ¶ 

func (*BaseReactor) Receive(chID byte, peer Peer, msgBytes []byte)

func (*BaseReactor) RemovePeer ¶ 

func (*BaseReactor) RemovePeer(peer Peer, reason interface{})

func (*BaseReactor) SetSwitch ¶ 

func (br *BaseReactor) SetSwitch(sw *Switch)

type ChannelDescriptor ¶ 

type ChannelDescriptor = conn.ChannelDescriptor

type ConnFilterFunc ¶ 

type ConnFilterFunc func(ConnSet, net.Conn, []net.IP) error

ConnFilterFunc to be implemented by filter hooks after a new connection has been established. The set of exisiting connections is passed along together with all resolved IPs for the new connection.

func ConnDuplicateIPFilter ¶ 

func ConnDuplicateIPFilter() ConnFilterFunc

ConnDuplicateIPFilter resolves and keeps all ips for an incoming connection and refuses new ones if they come from a known ip.

type ConnSet ¶ 

type ConnSet interface {
	Has(net.Conn) bool
	HasIP(net.IP) bool
	Set(net.Conn, []net.IP)
	Remove(net.Conn)
	RemoveAddr(net.Addr)
}

ConnSet is a lookup table for connections and all their ips.

type ConnectionStatus ¶ 

type ConnectionStatus = conn.ConnectionStatus

type DefaultNodeInfo ¶ 

type DefaultNodeInfo struct {
	ProtocolVersion ProtocolVersion `json:"protocol_version"`

	// Authenticate
	// TODO: replace with NetAddress
	ID_        ID     `json:"id"`          // authenticated identifier
	ListenAddr string `json:"listen_addr"` // accepting incoming

	// Check compatibility.
	// Channels are HexBytes so easier to read as JSON
	Network  string       `json:"network"`  // network/chain ID
	Version  string       `json:"version"`  // major.minor.revision
	Channels cmn.HexBytes `json:"channels"` // channels this node knows about

	// ASCIIText fields
	Moniker string               `json:"moniker"` // arbitrary moniker
	Other   DefaultNodeInfoOther `json:"other"`   // other application specific data
}

DefaultNodeInfo is the basic node information exchanged between two peers during the Tendermint P2P handshake.

func (DefaultNodeInfo) CompatibleWith ¶ 

func (info DefaultNodeInfo) CompatibleWith(other_ NodeInfo) error

CompatibleWith checks if two DefaultNodeInfo are compatible with eachother. CONTRACT: two nodes are compatible if the Block version and network match and they have at least one channel in common.

func (DefaultNodeInfo) ID ¶ 

func (info DefaultNodeInfo) ID() ID

ID returns the node's peer ID.

func (*DefaultNodeInfo) Marshal ¶ 

func (info *DefaultNodeInfo) Marshal() ([]byte, error)

Marshal returns the amino encoding.

func (*DefaultNodeInfo) MarshalTo ¶ 

func (info *DefaultNodeInfo) MarshalTo(data []byte) (int, error)

MarshalTo calls Marshal and copies to the given buffer.

func (DefaultNodeInfo) NetAddress ¶ 

func (info DefaultNodeInfo) NetAddress() *NetAddress

NetAddress returns a NetAddress derived from the DefaultNodeInfo - it includes the authenticated peer ID and the self-reported ListenAddr. Note that the ListenAddr is not authenticated and may not match that address actually dialed if its an outbound peer.

func (*DefaultNodeInfo) Size ¶ 

func (info *DefaultNodeInfo) Size() int

Size returns the size of the amino encoding, in bytes.

func (*DefaultNodeInfo) Unmarshal ¶ 

func (info *DefaultNodeInfo) Unmarshal(bs []byte) error

Unmarshal deserializes from amino encoded form.

func (DefaultNodeInfo) Validate ¶ 

func (info DefaultNodeInfo) Validate() error

Validate checks the self-reported DefaultNodeInfo is safe. It returns an error if there are too many Channels, if there are any duplicate Channels, if the ListenAddr is malformed, or if the ListenAddr is a host name that can not be resolved to some IP. TODO: constraints for Moniker/Other? Or is that for the UI ? JAE: It needs to be done on the client, but to prevent ambiguous unicode characters, maybe it's worth sanitizing it here. In the future we might want to validate these, once we have a name-resolution system up. International clients could then use punycode (or we could use url-encoding), and we just need to be careful with how we handle that in our clients. (e.g. off by default).

type DefaultNodeInfoOther ¶ 

type DefaultNodeInfoOther struct {
	TxIndex    string `json:"tx_index"`
	RPCAddress string `json:"rpc_address"`
}

DefaultNodeInfoOther is the misc. applcation specific data

type ErrFilterTimeout ¶ 

type ErrFilterTimeout struct{}

ErrFilterTimeout indicates that a filter operation timed out.

func (ErrFilterTimeout) Error ¶ 

func (e ErrFilterTimeout) Error() string

type ErrNetAddressInvalid ¶ 

type ErrNetAddressInvalid struct {
	Addr string
	Err  error
}

func (ErrNetAddressInvalid) Error ¶ 

func (e ErrNetAddressInvalid) Error() string

type ErrNetAddressLookup ¶ 

type ErrNetAddressLookup struct {
	Addr string
	Err  error
}

func (ErrNetAddressLookup) Error ¶ 

func (e ErrNetAddressLookup) Error() string

type ErrNetAddressNoID ¶ 

type ErrNetAddressNoID struct {
	Addr string
}

func (ErrNetAddressNoID) Error ¶ 

func (e ErrNetAddressNoID) Error() string

type ErrRejected ¶ 

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

ErrRejected indicates that a Peer was rejected carrying additional information as to the reason.

func (ErrRejected) Addr ¶ 

func (e ErrRejected) Addr() NetAddress

Addr returns the NetAddress for the rejected Peer.

func (ErrRejected) Error ¶ 

func (e ErrRejected) Error() string

func (ErrRejected) IsAuthFailure ¶ 

func (e ErrRejected) IsAuthFailure() bool

IsAuthFailure when Peer authentication was unsuccessful.

func (ErrRejected) IsDuplicate ¶ 

func (e ErrRejected) IsDuplicate() bool

IsDuplicate when Peer ID or IP are present already.

func (ErrRejected) IsFiltered ¶ 

func (e ErrRejected) IsFiltered() bool

IsFiltered when Peer ID or IP was filtered.

func (ErrRejected) IsIncompatible ¶ 

func (e ErrRejected) IsIncompatible() bool

IsIncompatible when Peer NodeInfo is not compatible with our own.

func (ErrRejected) IsNodeInfoInvalid ¶ 

func (e ErrRejected) IsNodeInfoInvalid() bool

IsNodeInfoInvalid when the sent NodeInfo is not valid.

func (ErrRejected) IsSelf ¶ 

func (e ErrRejected) IsSelf() bool

IsSelf when Peer is our own node.

type ErrSwitchAuthenticationFailure ¶ 

type ErrSwitchAuthenticationFailure struct {
	Dialed *NetAddress
	Got    ID
}

func (ErrSwitchAuthenticationFailure) Error ¶ 

func (e ErrSwitchAuthenticationFailure) Error() string

type ErrSwitchConnectToSelf ¶ 

type ErrSwitchConnectToSelf struct {
	Addr *NetAddress
}

ErrSwitchConnectToSelf to be raised when trying to connect to itself.

func (ErrSwitchConnectToSelf) Error ¶ 

func (e ErrSwitchConnectToSelf) Error() string

type ErrSwitchDuplicatePeerID ¶ 

type ErrSwitchDuplicatePeerID struct {
	ID ID
}

ErrSwitchDuplicatePeerID to be raised when a peer is connecting with a known ID.

func (ErrSwitchDuplicatePeerID) Error ¶ 

func (e ErrSwitchDuplicatePeerID) Error() string

type ErrSwitchDuplicatePeerIP ¶ 

type ErrSwitchDuplicatePeerIP struct {
	IP net.IP
}

ErrSwitchDuplicatePeerIP to be raised whena a peer is connecting with a known IP.

func (ErrSwitchDuplicatePeerIP) Error ¶ 

func (e ErrSwitchDuplicatePeerIP) Error() string

type ErrTransportClosed ¶ 

type ErrTransportClosed struct{}

ErrTransportClosed is raised when the Transport has been closed.

func (ErrTransportClosed) Error ¶ 

func (e ErrTransportClosed) Error() string

type FuzzedConnection ¶ 

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

FuzzedConnection wraps any net.Conn and depending on the mode either delays reads/writes or randomly drops reads/writes/connections.

func (*FuzzedConnection) Close ¶ 

func (fc *FuzzedConnection) Close() error

Close implements net.Conn.

func (*FuzzedConnection) Config ¶ 

func (fc *FuzzedConnection) Config() *config.FuzzConnConfig

Config returns the connection's config.

func (*FuzzedConnection) LocalAddr ¶ 

func (fc *FuzzedConnection) LocalAddr() net.Addr

LocalAddr implements net.Conn.

func (*FuzzedConnection) Read ¶ 

func (fc *FuzzedConnection) Read(data []byte) (n int, err error)

Read implements net.Conn.

func (*FuzzedConnection) RemoteAddr ¶ 

func (fc *FuzzedConnection) RemoteAddr() net.Addr

RemoteAddr implements net.Conn.

func (*FuzzedConnection) SetDeadline ¶ 

func (fc *FuzzedConnection) SetDeadline(t time.Time) error

SetDeadline implements net.Conn.

func (*FuzzedConnection) SetReadDeadline ¶ 

func (fc *FuzzedConnection) SetReadDeadline(t time.Time) error

SetReadDeadline implements net.Conn.

func (*FuzzedConnection) SetWriteDeadline ¶ 

func (fc *FuzzedConnection) SetWriteDeadline(t time.Time) error

SetWriteDeadline implements net.Conn.

func (*FuzzedConnection) Write ¶ 

func (fc *FuzzedConnection) Write(data []byte) (n int, err error)

Write implements net.Conn.

type ID ¶ 

type ID string

ID is a hex-encoded crypto.Address

func PubKeyToID ¶ 

func PubKeyToID(pubKey crypto.PubKey) ID

PubKeyToID returns the ID corresponding to the given PubKey. It's the hex-encoding of the pubKey.Address().

type IPResolver ¶ 

type IPResolver interface {
	LookupIPAddr(context.Context, string) ([]net.IPAddr, error)
}

IPResolver is a behaviour subset of net.Resolver.

type IPeerSet ¶ 

type IPeerSet interface {
	Has(key ID) bool
	HasIP(ip net.IP) bool
	Get(key ID) Peer
	List() []Peer
	Size() int
}

IPeerSet has a (immutable) subset of the methods of PeerSet.

type Metrics ¶ 

type Metrics struct {
	// Number of peers.
	Peers metrics.Gauge
	// Number of bytes received from a given peer.
	PeerReceiveBytesTotal metrics.Counter
	// Number of bytes sent to a given peer.
	PeerSendBytesTotal metrics.Counter
	// Pending bytes to be sent to a given peer.
	PeerPendingSendBytes metrics.Gauge
	// Number of transactions submitted by each peer.
	NumTxs metrics.Gauge
}

Metrics contains metrics exposed by this package.

func NopMetrics ¶ 

func NopMetrics() *Metrics

NopMetrics returns no-op Metrics.

func PrometheusMetrics ¶ 

func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics

PrometheusMetrics returns Metrics build using Prometheus client library. Optionally, labels can be provided along with their values ("foo", "fooValue").

type MultiplexTransport ¶ 

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

MultiplexTransport accepts and dials tcp connections and upgrades them to multiplexed peers.

func NewMultiplexTransport ¶ 

func NewMultiplexTransport(
	nodeInfo NodeInfo,
	nodeKey NodeKey,
	mConfig conn.MConnConfig,
) *MultiplexTransport

NewMultiplexTransport returns a tcp connected multiplexed peer.

func (*MultiplexTransport) Accept ¶ 

func (mt *MultiplexTransport) Accept(cfg peerConfig) (Peer, error)

Accept implements Transport.

func (*MultiplexTransport) Cleanup ¶ 

func (mt *MultiplexTransport) Cleanup(p Peer)

Cleanup removes the given address from the connections set and closes the connection.

func (*MultiplexTransport) Close ¶ 

func (mt *MultiplexTransport) Close() error

Close implements transportLifecycle.

func (*MultiplexTransport) Dial ¶ 

func (mt *MultiplexTransport) Dial(
	addr NetAddress,
	cfg peerConfig,
) (Peer, error)

Dial implements Transport.

func (*MultiplexTransport) Listen ¶ 

func (mt *MultiplexTransport) Listen(addr NetAddress) error

Listen implements transportLifecycle.

type MultiplexTransportOption ¶ 

type MultiplexTransportOption func(*MultiplexTransport)

MultiplexTransportOption sets an optional parameter on the MultiplexTransport.

func MultiplexTransportConnFilters ¶ 

func MultiplexTransportConnFilters(
	filters ...ConnFilterFunc,
) MultiplexTransportOption

MultiplexTransportConnFilters sets the filters for rejection new connections.

func MultiplexTransportFilterTimeout ¶ 

func MultiplexTransportFilterTimeout(
	timeout time.Duration,
) MultiplexTransportOption

MultiplexTransportFilterTimeout sets the timeout waited for filter calls to return.

func MultiplexTransportResolver ¶ 

func MultiplexTransportResolver(resolver IPResolver) MultiplexTransportOption

MultiplexTransportResolver sets the Resolver used for ip lokkups, defaults to net.DefaultResolver.

type NetAddress ¶ 

type NetAddress struct {
	ID   ID     `json:"id"`
	IP   net.IP `json:"ip"`
	Port uint16 `json:"port"`
	// contains filtered or unexported fields
}

NetAddress defines information about a peer on the network including its ID, IP address, and port.

func CreateRoutableAddr ¶ 

func CreateRoutableAddr() (addr string, netAddr *NetAddress)

func NewNetAddress ¶ 

func NewNetAddress(id ID, addr net.Addr) *NetAddress

NewNetAddress returns a new NetAddress using the provided TCP address. When testing, other net.Addr (except TCP) will result in using 0.0.0.0:0. When normal run, other net.Addr (except TCP) will panic. TODO: socks proxies?

func NewNetAddressIPPort ¶ 

func NewNetAddressIPPort(ip net.IP, port uint16) *NetAddress

NewNetAddressIPPort returns a new NetAddress using the provided IP and port number.

func NewNetAddressString ¶ 

func NewNetAddressString(addr string) (*NetAddress, error)

NewNetAddressString returns a new NetAddress using the provided address in the form of "ID@IP:Port". Also resolves the host if host is not an IP. Errors are of type ErrNetAddressXxx where Xxx is in (NoID, Invalid, Lookup)

func NewNetAddressStringWithOptionalID ¶ 

func NewNetAddressStringWithOptionalID(addr string) (*NetAddress, error)

NewNetAddressStringWithOptionalID returns a new NetAddress using the provided address in the form of "ID@IP:Port", where the ID is optional. Also resolves the host if host is not an IP.

func NewNetAddressStrings ¶ 

func NewNetAddressStrings(addrs []string) ([]*NetAddress, []error)

NewNetAddressStrings returns an array of NetAddress'es build using the provided strings.

func (*NetAddress) Dial ¶ 

func (na *NetAddress) Dial() (net.Conn, error)

Dial calls net.Dial on the address.

func (*NetAddress) DialString ¶ 

func (na *NetAddress) DialString() string

func (*NetAddress) DialTimeout ¶ 

func (na *NetAddress) DialTimeout(timeout time.Duration) (net.Conn, error)

DialTimeout calls net.DialTimeout on the address.

func (*NetAddress) Equals ¶ 

func (na *NetAddress) Equals(other interface{}) bool

Equals reports whether na and other are the same addresses, including their ID, IP, and Port.

func (*NetAddress) HasID ¶ 

func (na *NetAddress) HasID() bool

HasID returns true if the address has an ID. NOTE: It does not check whether the ID is valid or not.

func (*NetAddress) Local ¶ 

func (na *NetAddress) Local() bool

Local returns true if it is a local address.

func (*NetAddress) RFC1918 ¶ 

func (na *NetAddress) RFC1918() bool

func (*NetAddress) RFC3849 ¶ 

func (na *NetAddress) RFC3849() bool

func (*NetAddress) RFC3927 ¶ 

func (na *NetAddress) RFC3927() bool

func (*NetAddress) RFC3964 ¶ 

func (na *NetAddress) RFC3964() bool

func (*NetAddress) RFC4193 ¶ 

func (na *NetAddress) RFC4193() bool

func (*NetAddress) RFC4380 ¶ 

func (na *NetAddress) RFC4380() bool

func (*NetAddress) RFC4843 ¶ 

func (na *NetAddress) RFC4843() bool

func (*NetAddress) RFC4862 ¶ 

func (na *NetAddress) RFC4862() bool

func (*NetAddress) RFC6052 ¶ 

func (na *NetAddress) RFC6052() bool

func (*NetAddress) RFC6145 ¶ 

func (na *NetAddress) RFC6145() bool

func (*NetAddress) ReachabilityTo ¶ 

func (na *NetAddress) ReachabilityTo(o *NetAddress) int

ReachabilityTo checks whenever o can be reached from na.

func (*NetAddress) Routable ¶ 

func (na *NetAddress) Routable() bool

Routable returns true if the address is routable.

func (*NetAddress) Same ¶ 

func (na *NetAddress) Same(other interface{}) bool

Same returns true is na has the same non-empty ID or DialString as other.

func (*NetAddress) String ¶ 

func (na *NetAddress) String() string

String representation: <ID>@<IP>:<PORT>

func (*NetAddress) Valid ¶ 

func (na *NetAddress) Valid() bool

For IPv4 these are either a 0 or all bits set address. For IPv6 a zero address or one that matches the RFC3849 documentation address format.

type NodeInfo ¶ 

type NodeInfo interface {
	// contains filtered or unexported methods
}

NodeInfo exposes basic info of a node and determines if we're compatible.

type NodeKey ¶ 

type NodeKey struct {
	PrivKey crypto.PrivKey `json:"priv_key"` // our priv key
}

NodeKey is the persistent peer key. It contains the nodes private key for authentication.

func LoadNodeKey ¶ 

func LoadNodeKey(filePath string) (*NodeKey, error)

func LoadOrGenNodeKey ¶ 

func LoadOrGenNodeKey(filePath string) (*NodeKey, error)

LoadOrGenNodeKey attempts to load the NodeKey from the given filePath. If the file does not exist, it generates and saves a new NodeKey.

func (*NodeKey) ID ¶ 

func (nodeKey *NodeKey) ID() ID

ID returns the peer's canonical ID - the hash of its public key.

func (*NodeKey) PubKey ¶ 

func (nodeKey *NodeKey) PubKey() crypto.PubKey

PubKey returns the peer's PubKey

type Peer ¶ 

type Peer interface {
	cmn.Service
	FlushStop()

	ID() ID               // peer's cryptographic ID
	RemoteIP() net.IP     // remote IP of the connection
	RemoteAddr() net.Addr // remote address of the connection

	IsOutbound() bool   // did we dial the peer
	IsPersistent() bool // do we redial this peer when we disconnect

	CloseConn() error // close original connection

	NodeInfo() NodeInfo // peer's info
	Status() tmconn.ConnectionStatus
	OriginalAddr() *NetAddress // original address for outbound peers

	Send(byte, []byte) bool
	TrySend(byte, []byte) bool

	Set(string, interface{})
	Get(string) interface{}
}

Peer is an interface representing a peer connected on a reactor.

type PeerFilterFunc ¶ 

type PeerFilterFunc func(IPeerSet, Peer) error

PeerFilterFunc to be implemented by filter hooks after a new Peer has been fully setup.

type PeerOption ¶ 

type PeerOption func(*peer)

func PeerMetrics ¶ 

func PeerMetrics(metrics *Metrics) PeerOption

type PeerSet ¶ 

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

PeerSet is a special structure for keeping a table of peers. Iteration over the peers is super fast and thread-safe.

func NewPeerSet ¶ 

func NewPeerSet() *PeerSet

NewPeerSet creates a new peerSet with a list of initial capacity of 256 items.

func (*PeerSet) Add ¶ 

func (ps *PeerSet) Add(peer Peer) error

Add adds the peer to the PeerSet. It returns an error carrying the reason, if the peer is already present.

func (*PeerSet) Get ¶ 

func (ps *PeerSet) Get(peerKey ID) Peer

Get looks up a peer by the provided peerKey. Returns nil if peer is not found.

func (*PeerSet) Has ¶ 

func (ps *PeerSet) Has(peerKey ID) bool

Has returns true if the set contains the peer referred to by this peerKey, otherwise false.

func (*PeerSet) HasIP ¶ 

func (ps *PeerSet) HasIP(peerIP net.IP) bool

HasIP returns true if the set contains the peer referred to by this IP address, otherwise false.

func (*PeerSet) List ¶ 

func (ps *PeerSet) List() []Peer

List returns the threadsafe list of peers.

func (*PeerSet) Remove ¶ 

func (ps *PeerSet) Remove(peer Peer) bool

Remove discards peer by its Key, if the peer was previously memoized. Returns true if the peer was removed, and false if it was not found. in the set.

func (*PeerSet) Size ¶ 

func (ps *PeerSet) Size() int

Size returns the number of unique items in the peerSet.

type ProtocolVersion ¶ 

type ProtocolVersion struct {
	P2P   version.Protocol `json:"p2p"`
	Block version.Protocol `json:"block"`
	App   version.Protocol `json:"app"`
}

ProtocolVersion contains the protocol versions for the software.

func NewProtocolVersion ¶ 

func NewProtocolVersion(p2p, block, app version.Protocol) ProtocolVersion

NewProtocolVersion returns a fully populated ProtocolVersion.

type Reactor ¶ 

type Reactor interface {
	cmn.Service // Start, Stop

	// SetSwitch allows setting a switch.
	SetSwitch(*Switch)

	// GetChannels returns the list of channel descriptors.
	GetChannels() []*conn.ChannelDescriptor

	// AddPeer is called by the switch when a new peer is added.
	AddPeer(peer Peer)

	// RemovePeer is called by the switch when the peer is stopped (due to error
	// or other reason).
	RemovePeer(peer Peer, reason interface{})

	// Receive is called when msgBytes is received from peer.
	//
	// NOTE reactor can not keep msgBytes around after Receive completes without
	// copying.
	//
	// CONTRACT: msgBytes are not nil.
	Receive(chID byte, peer Peer, msgBytes []byte)
}

type Switch ¶ 

type Switch struct {
	cmn.BaseService
	// contains filtered or unexported fields
}

Switch handles peer connections and exposes an API to receive incoming messages on `Reactors`. Each `Reactor` is responsible for handling incoming messages of one or more `Channels`. So while sending outgoing messages is typically performed on the peer, incoming messages are received on the reactor.

func MakeConnectedSwitches ¶ 

func MakeConnectedSwitches(cfg *config.P2PConfig, n int, initSwitch func(int, *Switch) *Switch, connect func([]*Switch, int, int)) []*Switch

MakeConnectedSwitches returns n switches, connected according to the connect func. If connect==Connect2Switches, the switches will be fully connected. initSwitch defines how the i'th switch should be initialized (ie. with what reactors). NOTE: panics if any switch fails to start.

func MakeSwitch ¶ 

func MakeSwitch(
	cfg *config.P2PConfig,
	i int,
	network, version string,
	initSwitch func(int, *Switch) *Switch,
	opts ...SwitchOption,
) *Switch

func NewSwitch ¶ 

func NewSwitch(
	cfg *config.P2PConfig,
	transport Transport,
	options ...SwitchOption,
) *Switch

NewSwitch creates a new Switch with the given config.

func (*Switch) AddReactor ¶ 

func (sw *Switch) AddReactor(name string, reactor Reactor) Reactor

AddReactor adds the given reactor to the switch. NOTE: Not goroutine safe.

func (*Switch) Broadcast ¶ 

func (sw *Switch) Broadcast(chID byte, msgBytes []byte) chan bool

Broadcast runs a go routine for each attempted send, which will block trying to send for defaultSendTimeoutSeconds. Returns a channel which receives success values for each attempted send (false if times out). Channel will be closed once msg bytes are sent to all peers (or time out).

NOTE: Broadcast uses goroutines, so order of broadcast may not be preserved.

func (*Switch) DialPeerWithAddress ¶ 

func (sw *Switch) DialPeerWithAddress(addr *NetAddress, persistent bool) error

DialPeerWithAddress dials the given peer and runs sw.addPeer if it connects and authenticates successfully. If `persistent == true`, the switch will always try to reconnect to this peer if the connection ever fails.

func (*Switch) DialPeersAsync ¶ 

func (sw *Switch) DialPeersAsync(addrBook AddrBook, peers []string, persistent bool) error

DialPeersAsync dials a list of peers asynchronously in random order (optionally, making them persistent). Used to dial peers from config on startup or from unsafe-RPC (trusted sources). TODO: remove addrBook arg since it's now set on the switch

func (*Switch) IsDialingOrExistingAddress ¶ 

func (sw *Switch) IsDialingOrExistingAddress(addr *NetAddress) bool

IsDialingOrExistingAddress returns true if switch has a peer with the given address or dialing it at the moment.

func (*Switch) MarkPeerAsGood ¶ 

func (sw *Switch) MarkPeerAsGood(peer Peer)

MarkPeerAsGood marks the given peer as good when it did something useful like contributed to consensus.

func (*Switch) MaxNumOutboundPeers ¶ 

func (sw *Switch) MaxNumOutboundPeers() int

MaxNumOutboundPeers returns a maximum number of outbound peers.

func (*Switch) NodeInfo ¶ 

func (sw *Switch) NodeInfo() NodeInfo

NodeInfo returns the switch's NodeInfo. NOTE: Not goroutine safe.

func (*Switch) NumPeers ¶ 

func (sw *Switch) NumPeers() (outbound, inbound, dialing int)

NumPeers returns the count of outbound/inbound and outbound-dialing peers.

func (*Switch) OnStart ¶ 

func (sw *Switch) OnStart() error

OnStart implements BaseService. It starts all the reactors and peers.

func (*Switch) OnStop ¶ 

func (sw *Switch) OnStop()

OnStop implements BaseService. It stops all peers and reactors.

func (*Switch) Peers ¶ 

func (sw *Switch) Peers() IPeerSet

Peers returns the set of peers that are connected to the switch.

func (*Switch) Reactor ¶ 

func (sw *Switch) Reactor(name string) Reactor

Reactor returns the reactor with the given name. NOTE: Not goroutine safe.

func (*Switch) Reactors ¶ 

func (sw *Switch) Reactors() map[string]Reactor

Reactors returns a map of reactors registered on the switch. NOTE: Not goroutine safe.

func (*Switch) SetAddrBook ¶ 

func (sw *Switch) SetAddrBook(addrBook AddrBook)

SetAddrBook allows to set address book on Switch.

func (*Switch) SetNodeInfo ¶ 

func (sw *Switch) SetNodeInfo(nodeInfo NodeInfo)

SetNodeInfo sets the switch's NodeInfo for checking compatibility and handshaking with other nodes. NOTE: Not goroutine safe.

func (*Switch) SetNodeKey ¶ 

func (sw *Switch) SetNodeKey(nodeKey *NodeKey)

SetNodeKey sets the switch's private key for authenticated encryption. NOTE: Not goroutine safe.

func (*Switch) StopPeerForError ¶ 

func (sw *Switch) StopPeerForError(peer Peer, reason interface{})

StopPeerForError disconnects from a peer due to external error. If the peer is persistent, it will attempt to reconnect. TODO: make record depending on reason.

func (*Switch) StopPeerGracefully ¶ 

func (sw *Switch) StopPeerGracefully(peer Peer)

StopPeerGracefully disconnects from a peer gracefully. TODO: handle graceful disconnects.

type SwitchOption ¶ 

type SwitchOption func(*Switch)

SwitchOption sets an optional parameter on the Switch.

func SwitchFilterTimeout ¶ 

func SwitchFilterTimeout(timeout time.Duration) SwitchOption

SwitchFilterTimeout sets the timeout used for peer filters.

func SwitchPeerFilters ¶ 

func SwitchPeerFilters(filters ...PeerFilterFunc) SwitchOption

SwitchPeerFilters sets the filters for rejection of new peers.

func WithMetrics ¶ 

func WithMetrics(metrics *Metrics) SwitchOption

WithMetrics sets the metrics.

type Transport ¶ 

type Transport interface {
	// Accept returns a newly connected Peer.
	Accept(peerConfig) (Peer, error)

	// Dial connects to the Peer for the address.
	Dial(NetAddress, peerConfig) (Peer, error)

	// Cleanup any resources associated with Peer.
	Cleanup(Peer)
}

Transport emits and connects to Peers. The implementation of Peer is left to the transport. Each transport is also responsible to filter establishing peers specific to its domain.

Source Files ¶

View all Source files

Directories ¶

Path Synopsis
Taken from taipei-torrent.
 Taken from taipei-torrent.

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.