network

Documentation

Index

• Constants
• func TLSConfig(cert tls.Certificate) *tls.Config
• type Config
• type ConnMeter
  • func NewConnMeter(resetDuration time.Duration, connCacheSize, maxConns int) ConnMeter
• type HealthConfig
• type Network
  • func NewDefaultNetwork(registerer prometheus.Registerer, log logging.Logger, id ids.ShortID, ...) (Network, error)
  • func NewNetwork(registerer prometheus.Registerer, log logging.Logger, id ids.ShortID, ...) (Network, error)
• type PeerElement
• type PeerID
• type Upgrader
  • func NewTLSClientUpgrader(config *tls.Config) Upgrader
  • func NewTLSServerUpgrader(config *tls.Config) Upgrader

Constants

const (
	DefaultMaxMessageSize uint32 = 2 * units.MiB
)

reasonable default values

Functions

func TLSConfig

func TLSConfig(cert tls.Certificate) *tls.Config

Types

type Config

type Config struct {
	HealthConfig
	InboundThrottlerConfig  throttling.MsgThrottlerConfig
	OutboundThrottlerConfig throttling.MsgThrottlerConfig
	timer.AdaptiveTimeoutConfig
	DialerConfig     dialer.Config
	MetricsNamespace string
	// [Registerer] is set in node's initMetricsAPI method
	MetricsRegisterer prometheus.Registerer
}

type ConnMeter

type ConnMeter interface {
	// Returns whether we should allow an incoming connection from [ipStr]
	Allow(ipStr string) bool
}

ConnMeter keeps track of how many times a peer from a given address have attempted to connect to us in a given time period.

func NewConnMeter

func NewConnMeter(resetDuration time.Duration, connCacheSize, maxConns int) ConnMeter

Return a new connection meter that allows an incoming connection if we've allowed <= [maxConns] incoming connections from that address in the last [resetDuration]. Keeps the counters in a cache of size [connCacheSize]. If any argument is 0, returns a ConnMeter that allows all incoming connections.

type HealthConfig

type HealthConfig struct {
	// Must be connected to at least this many peers to be considered healthy
	MinConnectedPeers uint

	// Must have received a message from the network within this duration
	// to be considered healthy. Must be positive
	MaxTimeSinceMsgReceived time.Duration

	// Must have sent a message over the network within this duration
	// to be considered healthy. Must be positive
	MaxTimeSinceMsgSent time.Duration

	// If greater than this portion of the pending send byte queue is full,
	// will report unhealthy. Must be in (0,1]
	MaxPortionSendQueueBytesFull float64

	// If greater than this portion of the attempts to send a message to a peer
	// fail, will return unhealthy. Does not include send attempts that were not
	// made due to benching. Must be in [0,1]
	MaxSendFailRate float64

	// Halflife of averager used to calculate the send fail rate
	// Must be > 0.
	// Larger value --> Drop rate affected less by recent messages
	MaxSendFailRateHalflife time.Duration
}

HealthConfig describes parameters for network layer health checks.

type Network

type Network interface {
	// All consensus messages can be sent through this interface. Thread safety
	// must be managed internally in the network.
	sender.ExternalSender

	// The network must be able to broadcast accepted decisions to random peers.
	// Thread safety must be managed internally in the network.
	triggers.Acceptor

	// Should only be called once, will run until either a fatal error occurs,
	// or the network is closed. Returns a non-nil error.
	Dispatch() error

	// Attempt to connect to this IP. Thread safety must be managed internally
	// to the network. The network will never stop attempting to connect to this
	// IP.
	TrackIP(ip utils.IPDesc)

	// Attempt to connect to this node ID at IP. Thread safety must be managed
	// internally to the network.
	Track(ip utils.IPDesc, nodeID ids.ShortID)

	// Returns the description of the specified [nodeIDs] this network is currently
	// connected to externally or all nodes this network is connected to if [nodeIDs]
	// is empty. Thread safety must be managed internally to the network.
	Peers(nodeIDs []ids.ShortID) []PeerID

	// Close this network and all existing connections it has. Thread safety
	// must be managed internally to the network. Calling close multiple times
	// will return a nil error.
	Close() error

	// Return the IP of the node
	IP() utils.IPDesc

	// Has a health check
	health.Checkable
}

Network defines the functionality of the networking library.

func NewDefaultNetwork

func NewDefaultNetwork(
	registerer prometheus.Registerer,
	log logging.Logger,
	id ids.ShortID,
	ip utils.DynamicIPDesc,
	networkID uint32,
	versionCompatibility version.Compatibility,
	parser version.ApplicationParser,
	listener net.Listener,
	dialer dialer.Dialer,
	serverUpgrader,
	clientUpgrader Upgrader,
	vdrs validators.Set,
	beacons validators.Set,
	router router.Router,
	connMeterResetDuration time.Duration,
	connMeterMaxConns int,
	healthConfig HealthConfig,
	benchlistManager benchlist.Manager,
	peerAliasTimeout time.Duration,
	tlsKey crypto.Signer,
	peerListSize int,
	peerListGossipSize int,
	peerListGossipFreq time.Duration,
	isFetchOnly bool,
	gossipAcceptedFrontierSize uint,
	gossipOnAcceptSize uint,
	compressionEnabled bool,
	inboundMsgThrottler throttling.InboundMsgThrottler,
	outboundMsgThrottler throttling.OutboundMsgThrottler,
) (Network, error)

NewDefaultNetwork returns a new Network implementation with the provided parameters and some reasonable default values.

func NewNetwork

func NewNetwork(
	registerer prometheus.Registerer,
	log logging.Logger,
	id ids.ShortID,
	ip utils.DynamicIPDesc,
	networkID uint32,
	versionCompatibility version.Compatibility,
	parser version.ApplicationParser,
	listener net.Listener,
	dialer dialer.Dialer,
	serverUpgrader,
	clientUpgrader Upgrader,
	vdrs validators.Set,
	beacons validators.Set,
	router router.Router,
	initialReconnectDelay,
	maxReconnectDelay time.Duration,
	maxMessageSize uint32,
	maxClockDifference time.Duration,
	peerListSize int,
	peerListGossipFreq time.Duration,
	peerListGossipSize int,
	peerListStakerGossipFraction int,
	getVersionTimeout time.Duration,
	allowPrivateIPs bool,
	gossipAcceptedFrontierSize uint,
	gossipOnAcceptSize uint,
	pingPongTimeout time.Duration,
	pingFrequency time.Duration,
	readBufferSize uint32,
	readHandshakeTimeout time.Duration,
	connMeterResetDuration time.Duration,
	connMeterCacheSize int,
	connMeterMaxConns int,
	healthConfig HealthConfig,
	benchlistManager benchlist.Manager,
	peerAliasTimeout time.Duration,
	tlsKey crypto.Signer,
	isFetchOnly bool,
	compressionEnabled bool,
	inboundMsgThrottler throttling.InboundMsgThrottler,
	outboundMsgThrottler throttling.OutboundMsgThrottler,
) (Network, error)

NewNetwork returns a new Network implementation with the provided parameters.

type PeerElement

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

holds onto the peer object as a result of helper functions

type PeerID

type PeerID struct {
	IP           string    `json:"ip"`
	PublicIP     string    `json:"publicIP"`
	ID           string    `json:"nodeID"`
	Version      string    `json:"version"`
	LastSent     time.Time `json:"lastSent"`
	LastReceived time.Time `json:"lastReceived"`
	Benched      []ids.ID  `json:"benched"`
}

PeerID ...

type Upgrader

type Upgrader interface {
	// Must be thread safe
	Upgrade(net.Conn) (ids.ShortID, net.Conn, *x509.Certificate, error)
}

Upgrader ...

func NewTLSClientUpgrader

func NewTLSClientUpgrader(config *tls.Config) Upgrader

NewTLSClientUpgrader ...

func NewTLSServerUpgrader

func NewTLSServerUpgrader(config *tls.Config) Upgrader

NewTLSServerUpgrader ...