Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/tendermint/go-p2p
DEPRECATED (moved to tendermint/tendermint): Golang P2P library
https://github.com/tendermint/go-p2p
Last synced: 3 months ago
JSON representation
DEPRECATED (moved to tendermint/tendermint): Golang P2P library
- Host: GitHub
- URL: https://github.com/tendermint/go-p2p
- Owner: tendermint
- License: other
- Archived: true
- Created: 2015-10-22T20:00:51.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2017-04-21T22:02:35.000Z (about 7 years ago)
- Last Synced: 2024-01-17T20:34:00.290Z (5 months ago)
- Language: Go
- Homepage:
- Size: 224 KB
- Stars: 120
- Watchers: 34
- Forks: 32
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Lists
- awesome-stars - go-p2p - DEPRECATED (moved to tendermint/tendermint): Golang P2P library (Go)
README
# `tendermint/go-p2p`
[](https://circleci.com/gh/tendermint/go-p2p)
`tendermint/go-p2p` provides an abstraction around peer-to-peer communication.
## Peer/MConnection/Channel
Each peer has one `MConnection` (multiplex connection) instance.
__multiplex__ *noun* a system or signal involving simultaneous transmission of
several messages along a single channel of communication.
Each `MConnection` handles message transmission on multiple abstract communication
`Channel`s. Each channel has a globally unique byte id.
The byte id and the relative priorities of each `Channel` are configured upon
initialization of the connection.
There are two methods for sending messages:
```go
func (m MConnection) Send(chID byte, msg interface{}) bool {}
func (m MConnection) TrySend(chID byte, msg interface{}) bool {}
```
`Send(chID, msg)` is a blocking call that waits until `msg` is successfully queued
for the channel with the given id byte `chID`. The message `msg` is serialized
using the `tendermint/wire` submodule's `WriteBinary()` reflection routine.
`TrySend(chID, msg)` is a nonblocking call that returns false if the channel's
queue is full.
`Send()` and `TrySend()` are also exposed for each `Peer`.
## Switch/Reactor
The `Switch` handles peer connections and exposes an API to receive incoming messages
on `Reactors`. Each `Reactor` is responsible for handling incoming messages of one
or more `Channels`. So while sending outgoing messages is typically performed on the peer,
incoming messages are received on the reactor.
```go
// Declare a MyReactor reactor that handles messages on MyChannelID.
type MyReactor struct{}
func (reactor MyReactor) GetChannels() []*ChannelDescriptor {
return []*ChannelDescriptor{ChannelDescriptor{ID:MyChannelID, Priority: 1}}
}
func (reactor MyReactor) Receive(chID byte, peer *Peer, msgBytes []byte) {
r, n, err := bytes.NewBuffer(msgBytes), new(int64), new(error)
msgString := ReadString(r, n, err)
fmt.Println(msgString)
}
// Other Reactor methods omitted for brevity
...
switch := NewSwitch([]Reactor{MyReactor{}})
...
// Send a random message to all outbound connections
for _, peer := range switch.Peers().List() {
if peer.IsOutbound() {
peer.Send(MyChannelID, "Here's a random message")
}
}
```
### PexReactor/AddrBook
A `PEXReactor` reactor implementation is provided to automate peer discovery.
```go
book := p2p.NewAddrBook(addrBookFilePath)
pexReactor := p2p.NewPEXReactor(book)
...
switch := NewSwitch([]Reactor{pexReactor, myReactor, ...})
```