Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func NoPrecondition ¶
Types ¶
type Config ¶
type Config struct { // Size, in bytes, of the buffer this peer reads messages into ReadBufferSize int // Size, in bytes, of the buffer this peer writes messages into WriteBufferSize int Clock mockable.Clock Metrics *Metrics MessageCreator message.Creator Log logging.Logger InboundMsgThrottler throttling.InboundMsgThrottler Network Network Router router.InboundHandler VersionCompatibility version.Compatibility // MySubnets does not include the primary network ID MySubnets set.Set[ids.ID] Beacons validators.Manager Validators validators.Manager NetworkID uint32 PingFrequency time.Duration PongTimeout time.Duration MaxClockDifference time.Duration SupportedACPs []uint32 ObjectedACPs []uint32 // Unix time of the last message sent and received respectively // Must only be accessed atomically LastSent, LastReceived int64 // Tracks CPU/disk usage caused by each peer. ResourceTracker tracker.ResourceTracker // Calculates uptime of peers UptimeCalculator uptime.Calculator // Signs my IP so I can send my signed IP address in the Handshake message IPSigner *IPSigner }
type IPSigner ¶
type IPSigner struct {
// contains filtered or unexported fields
}
IPSigner will return a signedIP for the current value of our dynamic IP.
func NewIPSigner ¶
func (*IPSigner) GetSignedIP ¶
GetSignedIP returns the signedIP of the current value of the provided dynamicIP. If the dynamicIP hasn't changed since the prior call to GetSignedIP, then the same SignedIP will be returned.
It's safe for multiple goroutines to concurrently call GetSignedIP.
type Info ¶
type Info struct { IP string `json:"ip"` PublicIP string `json:"publicIP,omitempty"` ID ids.NodeID `json:"nodeID"` Version string `json:"version"` LastSent time.Time `json:"lastSent"` LastReceived time.Time `json:"lastReceived"` ObservedUptime json.Uint32 `json:"observedUptime"` ObservedSubnetUptimes map[ids.ID]json.Uint32 `json:"observedSubnetUptimes"` TrackedSubnets set.Set[ids.ID] `json:"trackedSubnets"` SupportedACPs set.Set[uint32] `json:"supportedACPs"` ObjectedACPs set.Set[uint32] `json:"objectedACPs"` }
type MessageQueue ¶
type MessageQueue interface { // Push attempts to add the message to the queue. If the context is // canceled, then pushing the message will return `false` and the message // will not be added to the queue. Push(ctx context.Context, msg message.OutboundMessage) bool // Pop blocks until a message is available and then returns the message. If // the queue is closed, then `false` is returned. Pop() (message.OutboundMessage, bool) // PopNow attempts to return a message without blocking. If a message is not // available or the queue is closed, then `false` is returned. PopNow() (message.OutboundMessage, bool) // Close empties the queue and prevents further messages from being pushed // onto it. After calling close once, future calls to close will do nothing. Close() }
func NewBlockingMessageQueue ¶
func NewBlockingMessageQueue( onFailed SendFailedCallback, log logging.Logger, bufferSize int, ) MessageQueue
func NewThrottledMessageQueue ¶
func NewThrottledMessageQueue( onFailed SendFailedCallback, id ids.NodeID, log logging.Logger, outboundMsgThrottler throttling.OutboundMsgThrottler, ) MessageQueue
type Metrics ¶
type Metrics struct { ClockSkewCount prometheus.Counter ClockSkewSum prometheus.Gauge NumFailedToParse prometheus.Counter NumSendFailed *prometheus.CounterVec // op Messages *prometheus.CounterVec // io + op + compressed Bytes *prometheus.CounterVec // io + op BytesSaved *prometheus.GaugeVec // io + op }
func NewMetrics ¶
func NewMetrics( namespace string, registerer prometheus.Registerer, ) (*Metrics, error)
func (*Metrics) MultipleSendsFailed ¶
func (*Metrics) SendFailed ¶
func (m *Metrics) SendFailed(msg message.OutboundMessage)
SendFailed updates the metrics for having failed to send [msg].
func (*Metrics) Sent ¶
func (m *Metrics) Sent(msg message.OutboundMessage)
Sent updates the metrics for having sent [msg].
type Network ¶
type Network interface { // Connected is called by the peer once the handshake is finished. Connected(peerID ids.NodeID) // AllowConnection enables the network is signal to the peer that its // connection is no longer desired and should be terminated. AllowConnection(peerID ids.NodeID) bool // Track allows the peer to notify the network of potential new peers to // connect to. Track(ips []*ips.ClaimedIPPort) error // Disconnected is called when the peer finishes shutting down. It is not // guaranteed that [Connected] was called for the provided peer. However, it // is guaranteed that [Connected] will not be called after [Disconnected] // for a given [Peer] object. Disconnected(peerID ids.NodeID) // KnownPeers returns the bloom filter of the known peers. KnownPeers() (bloomFilter []byte, salt []byte) // Peers returns peers that are not known. Peers( peerID ids.NodeID, knownPeers *bloom.ReadFilter, peerSalt []byte, ) []*ips.ClaimedIPPort }
Network defines the interface that is used by a peer to help establish a well connected p2p network.
var TestNetwork Network = testNetwork{}
type Peer ¶
type Peer interface { // ID returns the nodeID of the remote peer. ID() ids.NodeID // Cert returns the certificate that the remote peer is using to // authenticate their messages. Cert() *staking.Certificate // LastSent returns the last time a message was sent to the peer. LastSent() time.Time // LastReceived returns the last time a message was received from the peer. LastReceived() time.Time // Ready returns true if the peer has finished the p2p handshake and is // ready to send and receive messages. Ready() bool // AwaitReady will block until the peer has finished the p2p handshake. If // the context is cancelled or the peer starts closing, then an error will // be returned. AwaitReady(ctx context.Context) error // Info returns a description of the state of this peer. It should only be // called after [Ready] returns true. Info() Info // IP returns the claimed IP and signature provided by this peer during the // handshake. It should only be called after [Ready] returns true. IP() *SignedIP // Version returns the claimed node version this peer is running. It should // only be called after [Ready] returns true. Version() *version.Application // TrackedSubnets returns the subnets this peer is running. It should only // be called after [Ready] returns true. TrackedSubnets() set.Set[ids.ID] // ObservedUptime returns the local node's subnet uptime according to the // peer. The value ranges from [0, 100]. It should only be called after // [Ready] returns true. ObservedUptime(subnetID ids.ID) (uint32, bool) // Send attempts to send [msg] to the peer. The peer takes ownership of // [msg] for reference counting. This returns false if the message is // guaranteed not to be delivered to the peer. Send(ctx context.Context, msg message.OutboundMessage) bool // StartSendGetPeerList attempts to send a GetPeerList message to this peer // on this peer's gossip routine. It is not guaranteed that a GetPeerList // will be sent. StartSendGetPeerList() // StartClose will begin shutting down the peer. It will not block. StartClose() // Closed returns true once the peer has been fully shutdown. It is // guaranteed that no more messages will be received by this peer once this // returns true. Closed() bool // AwaitClosed will block until the peer has been fully shutdown. If the // context is cancelled, then an error will be returned. AwaitClosed(ctx context.Context) error }
Peer encapsulates all of the functionality required to send and receive messages with a remote peer.
func Start ¶
func Start( config *Config, conn net.Conn, cert *staking.Certificate, id ids.NodeID, messageQueue MessageQueue, ) Peer
Start a new peer instance.
Invariant: There must only be one peer running at a time with a reference to the same [config.InboundMsgThrottler].
func StartTestPeer ¶
func StartTestPeer( ctx context.Context, ip ips.IPPort, networkID uint32, router router.InboundHandler, ) (Peer, error)
StartTestPeer provides a simple interface to create a peer that has finished the p2p handshake.
This function will generate a new TLS key to use when connecting to the peer.
The returned peer will not throttle inbound or outbound messages.
- [ctx] provides a way of canceling the connection request.
- [ip] is the remote that will be dialed to create the connection.
- [networkID] will be sent to the peer during the handshake. If the peer is expecting a different [networkID], the handshake will fail and an error will be returned.
- router will be called with all non-handshake messages received by the peer.
Example ¶
ctx := context.Background() ctx, cancel := context.WithTimeout(ctx, 15*time.Second) defer cancel() peerIP := ips.IPPort{ IP: net.IPv6loopback, Port: 9651, } peer, err := StartTestPeer( ctx, peerIP, constants.LocalID, router.InboundHandlerFunc(func(_ context.Context, msg message.InboundMessage) { fmt.Printf("handling %s\n", msg.Op()) }), ) if err != nil { panic(err) } // Send messages here with [peer.Send]. peer.StartClose() err = peer.AwaitClosed(ctx) if err != nil { panic(err) }
Output:
type SendFailedCallback ¶
type SendFailedCallback interface {
SendFailed(message.OutboundMessage)
}
type SendFailedFunc ¶
type SendFailedFunc func(message.OutboundMessage)
func (SendFailedFunc) SendFailed ¶
func (f SendFailedFunc) SendFailed(msg message.OutboundMessage)
type Set ¶
type Set interface { // Add this peer to the set. // // If a peer with the same [peer.ID] is already in the set, then the new // peer instance will replace the old peer instance. // // Add does not change the [peer.ID] returned from calls to [GetByIndex]. Add(peer Peer) // GetByID attempts to fetch a [peer] whose [peer.ID] is equal to [nodeID]. // If no such peer exists in the set, then [false] will be returned. GetByID(nodeID ids.NodeID) (Peer, bool) // GetByIndex attempts to fetch a peer who has been allocated [index]. If // [index] < 0 or [index] >= [Len], then false will be returned. GetByIndex(index int) (Peer, bool) // Remove any [peer] whose [peer.ID] is equal to [nodeID] from the set. Remove(nodeID ids.NodeID) // Len returns the number of peers currently in this set. Len() int // Sample attempts to return a random slice of peers with length [n]. The // slice will not include any duplicates. Only peers that cause the // [precondition] to return true will be returned in the slice. Sample(n int, precondition func(Peer) bool) []Peer // Returns information about all the peers. AllInfo() []Info // Info returns information about the requested peers if they are in the // set. Info(nodeIDs []ids.NodeID) []Info }
Set contains a group of peers.
type SignedIP ¶
type SignedIP struct { UnsignedIP TLSSignature []byte BLSSignature *bls.Signature BLSSignatureBytes []byte }
SignedIP is a wrapper of an UnsignedIP with the signature from a signer.
type UnsignedIP ¶
UnsignedIP is used for a validator to claim an IP. The [Timestamp] is used to ensure that the most updated IP claim is tracked by peers for a given validator.
type Upgrader ¶
type Upgrader interface { // Must be thread safe Upgrade(net.Conn) (ids.NodeID, net.Conn, *staking.Certificate, error) }
func NewTLSClientUpgrader ¶
func NewTLSClientUpgrader(config *tls.Config, invalidCerts prometheus.Counter) Upgrader
func NewTLSServerUpgrader ¶
func NewTLSServerUpgrader(config *tls.Config, invalidCerts prometheus.Counter) Upgrader