network

package
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Feb 12, 2021 License: BSD-3-Clause Imports: 28 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},
	}
)

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

Functions

This section is empty.

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(ipDescs []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) 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
)

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 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

	// The network should be able to report the last time the network interacted
	// with a peer
	health.Heartbeater

	// 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.
	Track(ip utils.IPDesc)

	// 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
}

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,
	version version.Version,
	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,
	restarter utils.Restarter,
	restartOnDisconnected bool,
	disconnectedCheckFreq time.Duration,
	disconnectedRestartTimeout time.Duration,
	apricotPhase0Time time.Time,
	sendQueueSize uint32,
) 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,
	version version.Version,
	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,
	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,
	restarter utils.Restarter,
	restartOnDisconnected bool,
	disconnectedCheckFreq time.Duration,
	disconnectedRestartTimeout time.Duration,
	apricotPhase0Time time.Time,
) 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
)

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"`
	LastSent     time.Time `json:"lastSent"`
	LastReceived time.Time `json:"lastReceived"`
}

PeerID ...

type Upgrader 

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

Upgrader ...

func NewIPUpgrader 

func NewIPUpgrader() Upgrader

NewIPUpgrader ...

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.