go-ethereum: github.com/axiomzen/go-ethereum/p2p Index | Examples | Files | Directories

package p2p

import "github.com/axiomzen/go-ethereum/p2p"

Package p2p implements the Ethereum p2p network protocols.

Index

Examples

Package Files

dial.go message.go metrics.go peer.go peer_error.go protocol.go rlpx.go server.go util.go

Constants

const (
    MetricsInboundTraffic   = "p2p/ingress" // Name for the registered inbound traffic meter
    MetricsOutboundTraffic  = "p2p/egress"  // Name for the registered outbound traffic meter
    MetricsOutboundConnects = "p2p/dials"   // Name for the registered outbound connects meter
    MetricsInboundConnects  = "p2p/serves"  // Name for the registered inbound connects meter

    MeteredPeerLimit = 1024 // This amount of peers are individually metered
)

Variables

var (
    PeerIngressRegistry = metrics.NewPrefixedChildRegistry(metrics.EphemeralRegistry, MetricsInboundTraffic+"/")  // Registry containing the peer ingress
    PeerEgressRegistry  = metrics.NewPrefixedChildRegistry(metrics.EphemeralRegistry, MetricsOutboundTraffic+"/") // Registry containing the peer egress

)
var ErrPipeClosed = errors.New("p2p: read or write on closed message pipe")

ErrPipeClosed is returned from pipe operations after the pipe has been closed.

var (
    ErrShuttingDown = errors.New("shutting down")
)

func ExpectMsg Uses

func ExpectMsg(r MsgReader, code uint64, content interface{}) error

ExpectMsg reads a message from r and verifies that its code and encoded RLP content match the provided values. If content is nil, the payload is discarded and not verified.

func MsgPipe Uses

func MsgPipe() (*MsgPipeRW, *MsgPipeRW)

MsgPipe creates a message pipe. Reads on one end are matched with writes on the other. The pipe is full-duplex, both ends implement MsgReadWriter.

Code:

rw1, rw2 := MsgPipe()
go func() {
    Send(rw1, 8, [][]byte{{0, 0}})
    Send(rw1, 5, [][]byte{{1, 1}})
    rw1.Close()
}()

for {
    msg, err := rw2.ReadMsg()
    if err != nil {
        break
    }
    var data [][]byte
    msg.Decode(&data)
    fmt.Printf("msg: %d, %x\n", msg.Code, data[0])
}

Output:

msg: 8, 0000
msg: 5, 0101

func Send Uses

func Send(w MsgWriter, msgcode uint64, data interface{}) error

Send writes an RLP-encoded message with the given code. data should encode as an RLP list.

func SendItems Uses

func SendItems(w MsgWriter, msgcode uint64, elems ...interface{}) error

SendItems writes an RLP with the given code and data elements. For a call such as:

SendItems(w, code, e1, e2, e3)

the message payload will be an RLP list containing the items:

[e1, e2, e3]

func SubscribeMeteredPeerEvent Uses

func SubscribeMeteredPeerEvent(ch chan<- MeteredPeerEvent) event.Subscription

SubscribeMeteredPeerEvent registers a subscription for peer life-cycle events if metrics collection is enabled.

type Cap Uses

type Cap struct {
    Name    string
    Version uint
}

Cap is the structure of a peer capability.

func (Cap) String Uses

func (cap Cap) String() string

type Config Uses

type Config struct {
    // This field must be set to a valid secp256k1 private key.
    PrivateKey *ecdsa.PrivateKey `toml:"-"`

    // MaxPeers is the maximum number of peers that can be
    // connected. It must be greater than zero.
    MaxPeers int

    // MaxPendingPeers is the maximum number of peers that can be pending in the
    // handshake phase, counted separately for inbound and outbound connections.
    // Zero defaults to preset values.
    MaxPendingPeers int `toml:",omitempty"`

    // DialRatio controls the ratio of inbound to dialed connections.
    // Example: a DialRatio of 2 allows 1/2 of connections to be dialed.
    // Setting DialRatio to zero defaults it to 3.
    DialRatio int `toml:",omitempty"`

    // NoDiscovery can be used to disable the peer discovery mechanism.
    // Disabling is useful for protocol debugging (manual topology).
    NoDiscovery bool

    // DiscoveryV5 specifies whether the new topic-discovery based V5 discovery
    // protocol should be started or not.
    DiscoveryV5 bool `toml:",omitempty"`

    // Name sets the node name of this server.
    // Use common.MakeName to create a name that follows existing conventions.
    Name string `toml:"-"`

    // BootstrapNodes are used to establish connectivity
    // with the rest of the network.
    BootstrapNodes []*enode.Node

    // BootstrapNodesV5 are used to establish connectivity
    // with the rest of the network using the V5 discovery
    // protocol.
    BootstrapNodesV5 []*discv5.Node `toml:",omitempty"`

    // Static nodes are used as pre-configured connections which are always
    // maintained and re-connected on disconnects.
    StaticNodes []*enode.Node

    // Trusted nodes are used as pre-configured connections which are always
    // allowed to connect, even above the peer limit.
    TrustedNodes []*enode.Node

    // Connectivity can be restricted to certain IP networks.
    // If this option is set to a non-nil value, only hosts which match one of the
    // IP networks contained in the list are considered.
    NetRestrict *netutil.Netlist `toml:",omitempty"`

    // NodeDatabase is the path to the database containing the previously seen
    // live nodes in the network.
    NodeDatabase string `toml:",omitempty"`

    // Protocols should contain the protocols supported
    // by the server. Matching protocols are launched for
    // each peer.
    Protocols []Protocol `toml:"-"`

    // If ListenAddr is set to a non-nil address, the server
    // will listen for incoming connections.
    //
    // If the port is zero, the operating system will pick a port. The
    // ListenAddr field will be updated with the actual address when
    // the server is started.
    ListenAddr string

    // If set to a non-nil value, the given NAT port mapper
    // is used to make the listening port available to the
    // Internet.
    NAT nat.Interface `toml:",omitempty"`

    // If Dialer is set to a non-nil value, the given Dialer
    // is used to dial outbound peer connections.
    Dialer NodeDialer `toml:"-"`

    // If NoDial is true, the server will not dial any peers.
    NoDial bool `toml:",omitempty"`

    // If EnableMsgEvents is set then the server will emit PeerEvents
    // whenever a message is sent to or received from a peer
    EnableMsgEvents bool

    // Logger is a custom logger to use with the p2p.Server.
    Logger log.Logger `toml:",omitempty"`
}

Config holds Server options.

type DiscReason Uses

type DiscReason uint
const (
    DiscRequested DiscReason = iota
    DiscNetworkError
    DiscProtocolError
    DiscUselessPeer
    DiscTooManyPeers
    DiscAlreadyConnected
    DiscIncompatibleVersion
    DiscInvalidIdentity
    DiscQuitting
    DiscUnexpectedIdentity
    DiscSelf
    DiscReadTimeout
    DiscSubprotocolError = 0x10
)

func (DiscReason) Error Uses

func (d DiscReason) Error() string

func (DiscReason) String Uses

func (d DiscReason) String() string

type MeteredPeerEvent Uses

type MeteredPeerEvent struct {
    Type    MeteredPeerEventType // Type of peer event
    IP      net.IP               // IP address of the peer
    ID      enode.ID             // NodeID of the peer
    Elapsed time.Duration        // Time elapsed between the connection and the handshake/disconnection
    Ingress uint64               // Ingress count at the moment of the event
    Egress  uint64               // Egress count at the moment of the event
}

MeteredPeerEvent is an event emitted when peers connect or disconnect.

type MeteredPeerEventType Uses

type MeteredPeerEventType int

MeteredPeerEventType is the type of peer events emitted by a metered connection.

const (
    // PeerConnected is the type of event emitted when a peer successfully
    // made the handshake.
    PeerConnected MeteredPeerEventType = iota

    // PeerDisconnected is the type of event emitted when a peer disconnects.
    PeerDisconnected

    // PeerHandshakeFailed is the type of event emitted when a peer fails to
    // make the handshake or disconnects before the handshake.
    PeerHandshakeFailed
)

type Msg Uses

type Msg struct {
    Code       uint64
    Size       uint32 // size of the paylod
    Payload    io.Reader
    ReceivedAt time.Time
}

Msg defines the structure of a p2p message.

Note that a Msg can only be sent once since the Payload reader is consumed during sending. It is not possible to create a Msg and send it any number of times. If you want to reuse an encoded structure, encode the payload into a byte array and create a separate Msg with a bytes.Reader as Payload for each send.

func (Msg) Decode Uses

func (msg Msg) Decode(val interface{}) error

Decode parses the RLP content of a message into the given value, which must be a pointer.

For the decoding rules, please see package rlp.

func (Msg) Discard Uses

func (msg Msg) Discard() error

Discard reads any remaining payload data into a black hole.

func (Msg) String Uses

func (msg Msg) String() string

type MsgPipeRW Uses

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

MsgPipeRW is an endpoint of a MsgReadWriter pipe.

func (*MsgPipeRW) Close Uses

func (p *MsgPipeRW) Close() error

Close unblocks any pending ReadMsg and WriteMsg calls on both ends of the pipe. They will return ErrPipeClosed. Close also interrupts any reads from a message payload.

func (*MsgPipeRW) ReadMsg Uses

func (p *MsgPipeRW) ReadMsg() (Msg, error)

ReadMsg returns a message sent on the other end of the pipe.

func (*MsgPipeRW) WriteMsg Uses

func (p *MsgPipeRW) WriteMsg(msg Msg) error

WriteMsg sends a message on the pipe. It blocks until the receiver has consumed the message payload.

type MsgReadWriter Uses

type MsgReadWriter interface {
    MsgReader
    MsgWriter
}

MsgReadWriter provides reading and writing of encoded messages. Implementations should ensure that ReadMsg and WriteMsg can be called simultaneously from multiple goroutines.

type MsgReader Uses

type MsgReader interface {
    ReadMsg() (Msg, error)
}

type MsgWriter Uses

type MsgWriter interface {
    // WriteMsg sends a message. It will block until the message's
    // Payload has been consumed by the other end.
    //
    // Note that messages can be sent only once because their
    // payload reader is drained.
    WriteMsg(Msg) error
}

type NodeDialer Uses

type NodeDialer interface {
    Dial(*enode.Node) (net.Conn, error)
}

NodeDialer is used to connect to nodes in the network, typically by using an underlying net.Dialer but also using net.Pipe in tests

type NodeInfo Uses

type NodeInfo struct {
    ID    string `json:"id"`    // Unique node identifier (also the encryption key)
    Name  string `json:"name"`  // Name of the node, including client type, version, OS, custom data
    Enode string `json:"enode"` // Enode URL for adding this peer from remote peers
    ENR   string `json:"enr"`   // Ethereum Node Record
    IP    string `json:"ip"`    // IP address of the node
    Ports struct {
        Discovery int `json:"discovery"` // UDP listening port for discovery protocol
        Listener  int `json:"listener"`  // TCP listening port for RLPx
    }   `json:"ports"`
    ListenAddr string                 `json:"listenAddr"`
    Protocols  map[string]interface{} `json:"protocols"`
}

NodeInfo represents a short summary of the information known about the host.

type Peer Uses

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

Peer represents a connected remote node.

func NewPeer Uses

func NewPeer(id enode.ID, name string, caps []Cap) *Peer

NewPeer returns a peer for testing purposes.

func (*Peer) Caps Uses

func (p *Peer) Caps() []Cap

Caps returns the capabilities (supported subprotocols) of the remote peer.

func (*Peer) Disconnect Uses

func (p *Peer) Disconnect(reason DiscReason)

Disconnect terminates the peer connection with the given reason. It returns immediately and does not wait until the connection is closed.

func (*Peer) ID Uses

func (p *Peer) ID() enode.ID

ID returns the node's public key.

func (*Peer) Inbound Uses

func (p *Peer) Inbound() bool

Inbound returns true if the peer is an inbound connection

func (*Peer) Info Uses

func (p *Peer) Info() *PeerInfo

Info gathers and returns a collection of metadata known about a peer.

func (*Peer) LocalAddr Uses

func (p *Peer) LocalAddr() net.Addr

LocalAddr returns the local address of the network connection.

func (*Peer) Log Uses

func (p *Peer) Log() log.Logger

func (*Peer) Name Uses

func (p *Peer) Name() string

Name returns the node name that the remote node advertised.

func (*Peer) Node Uses

func (p *Peer) Node() *enode.Node

Node returns the peer's node descriptor.

func (*Peer) RemoteAddr Uses

func (p *Peer) RemoteAddr() net.Addr

RemoteAddr returns the remote address of the network connection.

func (*Peer) String Uses

func (p *Peer) String() string

String implements fmt.Stringer.

type PeerEvent Uses

type PeerEvent struct {
    Type     PeerEventType `json:"type"`
    Peer     enode.ID      `json:"peer"`
    Error    string        `json:"error,omitempty"`
    Protocol string        `json:"protocol,omitempty"`
    MsgCode  *uint64       `json:"msg_code,omitempty"`
    MsgSize  *uint32       `json:"msg_size,omitempty"`
}

PeerEvent is an event emitted when peers are either added or dropped from a p2p.Server or when a message is sent or received on a peer connection

type PeerEventType Uses

type PeerEventType string

PeerEventType is the type of peer events emitted by a p2p.Server

const (
    // PeerEventTypeAdd is the type of event emitted when a peer is added
    // to a p2p.Server
    PeerEventTypeAdd PeerEventType = "add"

    // PeerEventTypeDrop is the type of event emitted when a peer is
    // dropped from a p2p.Server
    PeerEventTypeDrop PeerEventType = "drop"

    // PeerEventTypeMsgSend is the type of event emitted when a
    // message is successfully sent to a peer
    PeerEventTypeMsgSend PeerEventType = "msgsend"

    // PeerEventTypeMsgRecv is the type of event emitted when a
    // message is received from a peer
    PeerEventTypeMsgRecv PeerEventType = "msgrecv"
)

type PeerInfo Uses

type PeerInfo struct {
    Enode   string   `json:"enode"` // Node URL
    ID      string   `json:"id"`    // Unique node identifier
    Name    string   `json:"name"`  // Name of the node, including client type, version, OS, custom data
    Caps    []string `json:"caps"`  // Protocols advertised by this peer
    Network struct {
        LocalAddress  string `json:"localAddress"`  // Local endpoint of the TCP data connection
        RemoteAddress string `json:"remoteAddress"` // Remote endpoint of the TCP data connection
        Inbound       bool   `json:"inbound"`
        Trusted       bool   `json:"trusted"`
        Static        bool   `json:"static"`
    }   `json:"network"`
    Protocols map[string]interface{} `json:"protocols"` // Sub-protocol specific metadata fields
}

PeerInfo represents a short summary of the information known about a connected peer. Sub-protocol independent fields are contained and initialized here, with protocol specifics delegated to all connected sub-protocols.

type Protocol Uses

type Protocol struct {
    // Name should contain the official protocol name,
    // often a three-letter word.
    Name string

    // Version should contain the version number of the protocol.
    Version uint

    // Length should contain the number of message codes used
    // by the protocol.
    Length uint64

    // Run is called in a new goroutine when the protocol has been
    // negotiated with a peer. It should read and write messages from
    // rw. The Payload for each message must be fully consumed.
    //
    // The peer connection is closed when Start returns. It should return
    // any protocol-level error (such as an I/O error) that is
    // encountered.
    Run func(peer *Peer, rw MsgReadWriter) error

    // NodeInfo is an optional helper method to retrieve protocol specific metadata
    // about the host node.
    NodeInfo func() interface{}

    // PeerInfo is an optional helper method to retrieve protocol specific metadata
    // about a certain peer in the network. If an info retrieval function is set,
    // but returns nil, it is assumed that the protocol handshake is still running.
    PeerInfo func(id enode.ID) interface{}

    // Attributes contains protocol specific information for the node record.
    Attributes []enr.Entry
}

Protocol represents a P2P subprotocol implementation.

type Server Uses

type Server struct {
    // Config fields may not be modified while the server is running.
    Config

    DiscV5 *discv5.Network
    // contains filtered or unexported fields
}

Server manages all peer connections.

func (*Server) AddPeer Uses

func (srv *Server) AddPeer(node *enode.Node)

AddPeer connects to the given node and maintains the connection until the server is shut down. If the connection fails for any reason, the server will attempt to reconnect the peer.

func (*Server) AddTrustedPeer Uses

func (srv *Server) AddTrustedPeer(node *enode.Node)

AddTrustedPeer adds the given node to a reserved whitelist which allows the node to always connect, even if the slot are full.

func (*Server) NodeInfo Uses

func (srv *Server) NodeInfo() *NodeInfo

NodeInfo gathers and returns a collection of metadata known about the host.

func (*Server) PeerCount Uses

func (srv *Server) PeerCount() int

PeerCount returns the number of connected peers.

func (*Server) Peers Uses

func (srv *Server) Peers() []*Peer

Peers returns all connected peers.

func (*Server) PeersInfo Uses

func (srv *Server) PeersInfo() []*PeerInfo

PeersInfo returns an array of metadata objects describing connected peers.

func (*Server) RemovePeer Uses

func (srv *Server) RemovePeer(node *enode.Node)

RemovePeer disconnects from the given node

func (*Server) RemoveTrustedPeer Uses

func (srv *Server) RemoveTrustedPeer(node *enode.Node)

RemoveTrustedPeer removes the given node from the trusted peer set.

func (*Server) Self Uses

func (srv *Server) Self() *enode.Node

Self returns the local node's endpoint information.

func (*Server) SetupConn Uses

func (srv *Server) SetupConn(fd net.Conn, flags connFlag, dialDest *enode.Node) error

SetupConn runs the handshakes and attempts to add the connection as a peer. It returns when the connection has been added as a peer or the handshakes have failed.

func (*Server) Start Uses

func (srv *Server) Start() (err error)

Start starts running the server. Servers can not be re-used after stopping.

func (*Server) Stop Uses

func (srv *Server) Stop()

Stop terminates the server and all active peer connections. It blocks until all active connections have been closed.

func (*Server) SubscribeEvents Uses

func (srv *Server) SubscribeEvents(ch chan *PeerEvent) event.Subscription

SubscribePeers subscribes the given channel to peer events

type TCPDialer Uses

type TCPDialer struct {
    *net.Dialer
}

TCPDialer implements the NodeDialer interface by using a net.Dialer to create TCP connections to nodes in the network

func (TCPDialer) Dial Uses

func (t TCPDialer) Dial(dest *enode.Node) (net.Conn, error)

Dial creates a TCP connection to the node

Directories

PathSynopsis
discoverPackage discover implements the Node Discovery Protocol.
discv5Package discv5 implements the RLPx v5 Topic Discovery Protocol.
enode
enrPackage enr implements Ethereum Node Records as defined in EIP-778.
natPackage nat provides access to common network port mapping protocols.
netutilPackage netutil contains extensions to the net package.
simulationsPackage simulations simulates p2p networks.
simulations/adapters
simulations/pipes
testing

Package p2p imports 38 packages (graph). Updated 2019-07-06. Refresh now. Tools for package owners.