network

package
v1.4.1 Latest Latest
Warning

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

 Go to latest Published: May 5, 2021 License: BSD-3-Clause Imports: 33 Imported by: 29

Documentation

Index

Constants

View Source 
const (
	DefaultMaxMessageSize uint32 = 1 << 21
)

reasonable default values

Variables

View Source 
var (
	Messages = map[Op][]Field{

		GetVersion:  {},
		Version:     {NetworkID, NodeID, MyTime, IP, VersionStr},
		GetPeerList: {},
		PeerList:    {Peers},
		Ping:        {},
		Pong:        {},

		GetAcceptedFrontier: {ChainID, RequestID, Deadline},
		AcceptedFrontier:    {ChainID, RequestID, ContainerIDs},
		GetAccepted:         {ChainID, RequestID, Deadline, ContainerIDs},
		Accepted:            {ChainID, RequestID, ContainerIDs},
		GetAncestors:        {ChainID, RequestID, Deadline, ContainerID},
		MultiPut:            {ChainID, RequestID, MultiContainerBytes},

		Get:       {ChainID, RequestID, Deadline, ContainerID},
		Put:       {ChainID, RequestID, ContainerID, ContainerBytes},
		PushQuery: {ChainID, RequestID, Deadline, ContainerID, ContainerBytes},
		PullQuery: {ChainID, RequestID, Deadline, ContainerID},
		Chits:     {ChainID, RequestID, ContainerIDs},

		SignedVersion:  {NetworkID, NodeID, MyTime, IP, VersionStr, VersionTime, SigBytes},
		SignedPeerList: {SignedPeers},
	}
)

Defines the messages that can be sent/received with this network

Functions

func TLSConfig added in v1.4.0 

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

Types

type Builder 

type Builder struct{ Codec }

Builder extends a Codec to build messages safely

func (Builder) Accepted 

func (m Builder) Accepted(chainID ids.ID, requestID uint32, containerIDs []ids.ID) (Msg, error)

Accepted message

func (Builder) AcceptedFrontier 

func (m Builder) AcceptedFrontier(chainID ids.ID, requestID uint32, containerIDs []ids.ID) (Msg, error)

AcceptedFrontier message

func (Builder) Chits 

func (m Builder) Chits(chainID ids.ID, requestID uint32, containerIDs []ids.ID) (Msg, error)

Chits message

func (Builder) Get 

func (m Builder) Get(chainID ids.ID, requestID uint32, deadline uint64, containerID ids.ID) (Msg, error)

Get message

func (Builder) GetAccepted 

func (m Builder) GetAccepted(chainID ids.ID, requestID uint32, deadline uint64, containerIDs []ids.ID) (Msg, error)

GetAccepted message

func (Builder) GetAcceptedFrontier 

func (m Builder) GetAcceptedFrontier(chainID ids.ID, requestID uint32, deadline uint64) (Msg, error)

GetAcceptedFrontier message

func (Builder) GetAncestors 

func (m Builder) GetAncestors(chainID ids.ID, requestID uint32, deadline uint64, containerID ids.ID) (Msg, error)

GetAncestors message

func (Builder) GetPeerList 

func (m Builder) GetPeerList() (Msg, error)

GetPeerList message

func (Builder) GetVersion 

func (m Builder) GetVersion() (Msg, error)

GetVersion message

func (Builder) MultiPut 

func (m Builder) MultiPut(chainID ids.ID, requestID uint32, containers [][]byte) (Msg, error)

MultiPut message

func (Builder) PeerList 

func (m Builder) PeerList(peers []utils.IPDesc) (Msg, error)

PeerList message

func (Builder) Ping 

func (m Builder) Ping() (Msg, error)

Ping message

func (Builder) Pong 

func (m Builder) Pong() (Msg, error)

Pong message

func (Builder) PullQuery 

func (m Builder) PullQuery(chainID ids.ID, requestID uint32, deadline uint64, containerID ids.ID) (Msg, error)

PullQuery message

func (Builder) PushQuery 

func (m Builder) PushQuery(chainID ids.ID, requestID uint32, deadline uint64, containerID ids.ID, container []byte) (Msg, error)

PushQuery message

func (Builder) Put 

func (m Builder) Put(chainID ids.ID, requestID uint32, containerID ids.ID, container []byte) (Msg, error)

Put message

func (Builder) SignedPeerList added in v1.4.0 

func (m Builder) SignedPeerList(peers []utils.IPCertDesc) (Msg, error)

func (Builder) SignedVersion added in v1.4.0 

func (m Builder) SignedVersion(networkID, nodeID uint32, myTime uint64, ip utils.IPDesc, myVersion string, myVersionTime uint64, sig []byte) (Msg, error)

SignedVersion message

func (Builder) Version 

func (m Builder) Version(networkID, nodeID uint32, myTime uint64, ip utils.IPDesc, myVersion string) (Msg, error)

Version message

type Codec 

type Codec struct{}

Codec defines the serialization and deserialization of network messages

func (Codec) Pack 

func (Codec) Pack(op Op, fields map[Field]interface{}) (Msg, error)

Pack attempts to pack a map of fields into a message. The first byte of the message is the opcode of the message.

func (Codec) Parse 

func (Codec) Parse(b []byte) (Msg, error)

Parse attempts to convert bytes into a message. The first byte of the message is the opcode of the message.

type ConnMeter added in v1.0.3 

type ConnMeter interface {
	// Register that the given address tried to connect to us.
	// Returns the number of times they previously tried.
	Register(addr string) (int, error)
}

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 added in v1.0.3 

func NewConnMeter(resetDuration time.Duration, size int) ConnMeter

Return a new connection counter If [resetDuration] is zero, returns a ConnMeter that always returns 0

type Dialer 

type Dialer interface {
	Dial(utils.IPDesc) (net.Conn, error)
}

Dialer attempts to create a connection with the provided IP/port pair

func NewDialer 

func NewDialer(network string) Dialer

NewDialer returns a new Dialer that calls `net.Dial` with the provided network.

type Field 

type Field uint32

Field that may be packed into a message 

const (
	VersionStr          Field = iota // Used in handshake
	NetworkID                        // Used in handshake
	NodeID                           // Used in handshake
	MyTime                           // Used in handshake
	IP                               // Used in handshake
	Peers                            // Used in handshake
	ChainID                          // Used for dispatching
	RequestID                        // Used for all messages
	Deadline                         // Used for request messages
	ContainerID                      // Used for querying
	ContainerBytes                   // Used for gossiping
	ContainerIDs                     // Used for querying
	MultiContainerBytes              // Used in MultiPut
	SigBytes                         // Used in handshake / peer gossiping
	VersionTime                      // Used in handshake / peer gossiping
	SignedPeers                      // Used in peer gossiping
)

Fields that may be packed. These values are not sent over the wire.

func (Field) Packer 

func (f Field) Packer() func(*wrappers.Packer, interface{})

Packer returns the packer function that can be used to pack this field.

func (Field) String 

func (f Field) String() string

func (Field) Unpacker 

func (f Field) Unpacker() func(*wrappers.Packer) interface{}

Unpacker returns the unpacker function that can be used to unpack this field.

type HealthConfig added in v1.2.1 

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 Msg 

type Msg interface {
	Op() Op
	Get(Field) interface{}
	Bytes() []byte
}

Msg represents a set of fields that can be serialized into a byte stream

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 node ID at IP. Thread safety must be managed internally
	// to the network. The network will never stop attempting to connect to this
	// IP.
	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.Parser,
	listener net.Listener,
	dialer Dialer,
	serverUpgrader,
	clientUpgrader Upgrader,
	vdrs validators.Set,
	beacons validators.Set,
	router router.Router,
	connMeterResetDuration time.Duration,
	connMeterMaxConns int,
	sendQueueSize uint32,
	healthConfig HealthConfig,
	benchlistManager benchlist.Manager,
	peerAliasTimeout time.Duration,
	tlsKey crypto.Signer,
) Network

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.Parser,
	listener net.Listener,
	dialer Dialer,
	serverUpgrader,
	clientUpgrader Upgrader,
	vdrs validators.Set,
	beacons validators.Set,
	router router.Router,
	initialReconnectDelay,
	maxReconnectDelay time.Duration,
	maxMessageSize uint32,
	sendQueueSize uint32,
	maxNetworkPendingSendBytes int,
	networkPendingSendBytesToRateLimit int,
	maxClockDifference time.Duration,
	peerListSize int,
	peerListGossipSpacing time.Duration,
	peerListGossipSize int,
	peerListStakerGossipFraction int,
	getVersionTimeout time.Duration,
	allowPrivateIPs bool,
	gossipSize int,
	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,
) Network

NewNetwork returns a new Network implementation with the provided parameters.

type Op 

type Op byte

Op is an opcode 

const (
	// Handshake:
	GetVersion Op = iota
	Version
	GetPeerList
	PeerList
	Ping
	Pong
	// Bootstrapping:
	GetAcceptedFrontier
	AcceptedFrontier
	GetAccepted
	Accepted
	GetAncestors
	MultiPut
	// Consensus:
	Get
	Put
	PushQuery
	PullQuery
	Chits
	// Handshake / peer gossiping
	SignedVersion
	SignedPeerList
)

Public commands that may be sent between stakers

func (Op) String 

func (op Op) String() string

type PeerElement added in v1.0.3 

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"`
	Up           bool      `json:"up"`
	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 ...

Source Files

View all Source files

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.