Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

p2p

package

Go to main page

Versions in this module

v0

v0.5.0

Jul 12, 2019

Changes in this version

+ const BlockCommitMsg

+ const BlockPrepareMsg

+ var NetworkNameToMagic = map[string]uint32

type BoxPeer

+ func (p *BoxPeer) BroadcastToBookkeepers(code uint32, msg conv.Convertible, bookkeepers []string) error

type DummyPeer

+ func (d *DummyPeer) BroadcastToBookkeepers(code uint32, msg conv.Convertible, bookkeepers []string) error

type Net

+ BroadcastToBookkeepers func(uint32, conv.Convertible, []string) error

v0.3.1

Mar 14, 2019

v0.3.0

Mar 5, 2019

Changes in this version

+ var ErrDuplicateMessage = errors.New("Duplicate message")

+ var ErrNoNeedToRelay = errors.New("Message no need to relay")

type BoxPeer

+ func (p *BoxPeer) Relay(code uint32, msg conv.Convertible) error

type Config

+ RelaySize uint32

type DummyPeer

+ func (d *DummyPeer) Relay(uint32, conv.Convertible) error

type Net

+ Relay func(uint32, conv.Convertible) error

v0.2.0

Nov 21, 2018

Changes in this version

+ const BlockChunkRequest

+ const BlockChunkResponse

+ const ConnLoadFactor

+ const ConnMaxCapacity

+ const EternalBlockMsg

+ const FixHeaderLength

+ const LightSyncReponse

+ const LightSyncRequest

+ const LocateCheckRequest

+ const LocateCheckResponse

+ const LocateForkPointRequest

+ const LocateForkPointResponse

+ const Mainnet

+ const MaxMessageDataLength

+ const MaxPeerCountToReplyPeerDiscover

+ const MaxPeerCountToSyncRouteTable

+ const NewBlockMsg

+ const PeerDiscover

+ const PeerDiscoverLoopInterval

+ const PeerDiscoverReply

+ const PeriodTime

+ const Ping

+ const PingBody

+ const Pong

+ const PongBody

+ const PriorityMsgTypeSize

+ const PriorityQueueCap

+ const ProtocolID

+ const Testnet

+ const TransactionMsg

+ var ErrBodyCheckSum = errors.New("body checksum is error")

+ var ErrExceedMaxDataLength = errors.New("exceed max data length")

+ var ErrFailedToSendMessageToPeer = errors.New("Failed to send message to peer")

+ var ErrFromProtoMessageMessage = errors.New("Invalid proto message")

+ var ErrHeaderCheckSum = errors.New("header checksum is error")

+ var ErrMagic = errors.New("magic is error")

+ var ErrMessageDataBody = errors.New("Invalid p2p message body")

+ var ErrMessageDataContent = errors.New("Invalid message data content")

+ var ErrMessageHeader = errors.New("Invalid p2p message header data")

+ var ErrMessageHeaderLength = errors.New("Can not read p2p message header length")

+ var ErrNoConnectionEstablished = errors.New("No connection established")

+ var NetworkNamtToMagic = map[string]uint32

+ func DecapsulatePeerMultiAddr(addr ma.Multiaddr) (ma.Multiaddr, peer.ID, error)

+ func EncapsulatePeerMultiAddr(addr ma.Multiaddr, peerid peer.ID) (ma.Multiaddr, error)

+ func PeerMultiAddr(h host.Host) (ma.Multiaddr, error)

+ func UpdateSynced(synced bool)

+ type BoxPeer struct

+ func NewBoxPeer(parent goprocess.Process, config *Config, s storage.Storage, bus eventbus.Bus) (*BoxPeer, error)

+ func (p *BoxPeer) AddAddrToPeerstore(addr string) error

+ func (p *BoxPeer) AddToPeerstore(maddr multiaddr.Multiaddr) error

+ func (p *BoxPeer) Broadcast(code uint32, msg conv.Convertible) error

+ func (p *BoxPeer) BroadcastToMiners(code uint32, msg conv.Convertible, miners []string) error

+ func (p *BoxPeer) Conns() *sync.Map

+ func (p *BoxPeer) Notify(msg Message)

+ func (p *BoxPeer) PeerSynced(peerID peer.ID) (bool, bool)

+ func (p *BoxPeer) PickOnePeer(peersExclusive ...peer.ID) peer.ID

+ func (p *BoxPeer) Proc() goprocess.Process

+ func (p *BoxPeer) Run() error

+ func (p *BoxPeer) SendMessageToPeer(code uint32, msg conv.Convertible, pid peer.ID) error

+ func (p *BoxPeer) Stop()

+ func (p *BoxPeer) Subscribe(notifiee *Notifiee)

+ func (p *BoxPeer) UnSubscribe(notifiee *Notifiee)

+ type Config struct

+ AddPeers []string

+ Address string

+ Bucketsize int

+ ConnLoadFactor float32

+ ConnMaxCapacity uint32

+ KeyPath string

+ Latency time.Duration

+ Magic uint32

+ Port uint32

+ Seeds []string

+ type Conn struct

+ func NewConn(stream libp2pnet.Stream, peer *BoxPeer, peerID peer.ID) *Conn

+ func (conn *Conn) Close() error

+ func (conn *Conn) Establish() bool

+ func (conn *Conn) Established() bool

+ func (conn *Conn) Handle(msg *remoteMessage) error

+ func (conn *Conn) Loop(parent goprocess.Process)

+ func (conn *Conn) OnPeerDiscover(body []byte) error

+ func (conn *Conn) OnPeerDiscoverReply(body []byte) error

+ func (conn *Conn) OnPing(data []byte) error

+ func (conn *Conn) OnPong(data []byte) error

+ func (conn *Conn) PeerDiscover() error

+ func (conn *Conn) Ping() error

+ func (conn *Conn) Write(opcode uint32, body []byte) error

+ type ConnManager struct

+ func NewConnManager(ps peerstore.Peerstore) *ConnManager

+ func (cm *ConnManager) ClosedStream(network net.Network, stream net.Stream)

+ func (cm *ConnManager) Connected(network net.Network, conn net.Conn)

+ func (cm *ConnManager) Disconnected(network net.Network, conn net.Conn)

+ func (cm *ConnManager) GetTagInfo(p peer.ID) *ifconnmgr.TagInfo

+ func (cm *ConnManager) Listen(network net.Network, multiaddr ma.Multiaddr)

+ func (cm *ConnManager) ListenClose(network net.Network, multiaddr ma.Multiaddr)

+ func (cm *ConnManager) Loop(parent goprocess.Process)

+ func (cm *ConnManager) Notifee() inet.Notifiee

+ func (cm *ConnManager) OpenedStream(network net.Network, stream net.Stream)

+ func (cm *ConnManager) Stop()

+ func (cm *ConnManager) TagPeer(p peer.ID, tag string, value int)

+ func (cm *ConnManager) TrimOpenConns(ctx context.Context)

+ func (cm *ConnManager) UntagPeer(p peer.ID, tag string)

+ type ConnStatus int

+ const ConnStatusConnected

+ const ConnStatusDisconnected

+ const ConnStatusNotTried

+ const ConnStatusTagName

+ func (cs ConnStatus) String() string

+ type DummyPeer struct

+ func NewDummyPeer() *DummyPeer

+ func (d *DummyPeer) Broadcast(uint32, conv.Convertible) error

+ func (d *DummyPeer) BroadcastToMiners(code uint32, msg conv.Convertible, miners []string) error

+ func (d *DummyPeer) Notify(Message)

+ func (d *DummyPeer) PeerSynced(peers peer.ID) (bool, bool)

+ func (d *DummyPeer) PickOnePeer(...peer.ID) peer.ID

+ func (d *DummyPeer) SendMessageToPeer(uint32, conv.Convertible, peer.ID) error

+ func (d *DummyPeer) Subscribe(*Notifiee)

+ func (d *DummyPeer) UnSubscribe(*Notifiee)

+ type Frequency uint32

+ const Repeatable

+ const Unique

+ const UniquePerPeer

+ type Message interface

+ Body func() []byte

+ Code func() uint32

+ From func() peer.ID

+ type Net interface

+ Broadcast func(uint32, conv.Convertible) error

+ BroadcastToMiners func(uint32, conv.Convertible, []string) error

+ Notify func(Message)

+ PeerSynced func(peers peer.ID) (bool, bool)

+ PickOnePeer func(peersExclusive ...peer.ID) peer.ID

+ SendMessageToPeer func(uint32, conv.Convertible, peer.ID) error

+ Subscribe func(*Notifiee)

+ UnSubscribe func(*Notifiee)

+ type Notifiee struct

+ func NewNotifiee(code uint32, frequency Frequency, messageCh chan Message) *Notifiee

+ type Notifier struct

+ func NewNotifier() *Notifier

+ func (notifier *Notifier) Loop(parent goprocess.Process)

+ func (notifier *Notifier) Notify(msg Message)

+ func (notifier *Notifier) Subscribe(notifiee *Notifiee)

+ func (notifier *Notifier) UnSubscribe(notifiee *Notifiee)

+ type ScoreManager struct

+ Mutex sync.Mutex

+ func NewScoreManager(parent goprocess.Process, bus eventbus.Bus, boxPeer *BoxPeer) *ScoreManager

+ type Table struct

+ func NewTable(peer *BoxPeer) *Table

+ func (t *Table) AddPeerToTable(conn *Conn)

+ func (t *Table) AddPeers(conn *Conn, peers *p2ppb.Peers)

+ func (t *Table) GetRandomPeers(pid peer.ID) []peerstore.PeerInfo

+ func (t *Table) Loop(parent goprocess.Process)