You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
244 lines
5.5 KiB
244 lines
5.5 KiB
package p2p
|
|
|
|
import (
|
|
"errors"
|
|
"net"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
. "github.com/tendermint/tendermint/binary"
|
|
. "github.com/tendermint/tendermint/common"
|
|
)
|
|
|
|
/*
|
|
All communication amongst peers are multiplexed by "channels".
|
|
(Not the same as Go "channels")
|
|
|
|
To send a message, serialize it into a ByteSlice and send it to each peer.
|
|
For best performance, re-use the same immutable ByteSlice to each peer.
|
|
You can also use a TypedBytes{} struct for convenience.
|
|
You can find all connected and active peers by iterating over ".Peers().List()".
|
|
".Broadcast()" is provided for convenience, but by iterating over
|
|
the peers manually the caller can decide which subset receives a message.
|
|
|
|
Inbound messages are received by calling ".Receive()".
|
|
The receiver is responsible for decoding the message bytes, which may be preceded
|
|
by a single type byte if a TypedBytes{} was used.
|
|
*/
|
|
type Switch struct {
|
|
chDescs []*ChannelDescriptor
|
|
recvQueues map[byte]chan InboundBytes
|
|
peers *PeerSet
|
|
dialing *CMap
|
|
listeners *CMap // listenerName -> chan interface{}
|
|
quit chan struct{}
|
|
started uint32
|
|
stopped uint32
|
|
}
|
|
|
|
var (
|
|
ErrSwitchStopped = errors.New("Switch already stopped")
|
|
ErrSwitchDuplicatePeer = errors.New("Duplicate peer")
|
|
)
|
|
|
|
const (
|
|
peerDialTimeoutSeconds = 30
|
|
)
|
|
|
|
func NewSwitch(chDescs []*ChannelDescriptor) *Switch {
|
|
s := &Switch{
|
|
chDescs: chDescs,
|
|
recvQueues: make(map[byte]chan InboundBytes),
|
|
peers: NewPeerSet(),
|
|
dialing: NewCMap(),
|
|
listeners: NewCMap(),
|
|
quit: make(chan struct{}),
|
|
stopped: 0,
|
|
}
|
|
|
|
// Create global recvQueues, one per channel.
|
|
for _, chDesc := range chDescs {
|
|
recvQueue := make(chan InboundBytes, chDesc.RecvQueueCapacity)
|
|
chDesc.recvQueue = recvQueue
|
|
s.recvQueues[chDesc.Id] = recvQueue
|
|
}
|
|
|
|
return s
|
|
}
|
|
|
|
func (s *Switch) Start() {
|
|
if atomic.CompareAndSwapUint32(&s.started, 0, 1) {
|
|
log.Info("Starting switch")
|
|
}
|
|
}
|
|
|
|
func (s *Switch) Stop() {
|
|
if atomic.CompareAndSwapUint32(&s.stopped, 0, 1) {
|
|
log.Info("Stopping switch")
|
|
close(s.quit)
|
|
// stop each peer.
|
|
for _, peer := range s.peers.List() {
|
|
peer.stop()
|
|
}
|
|
// empty tree.
|
|
s.peers = NewPeerSet()
|
|
}
|
|
}
|
|
|
|
func (s *Switch) AddPeerWithConnection(conn net.Conn, outbound bool) (*Peer, error) {
|
|
if atomic.LoadUint32(&s.stopped) == 1 {
|
|
return nil, ErrSwitchStopped
|
|
}
|
|
|
|
peer := newPeer(conn, outbound, s.chDescs, s.StopPeerForError)
|
|
|
|
// Add the peer to .peers
|
|
if s.peers.Add(peer) {
|
|
log.Info("+ %v", peer)
|
|
} else {
|
|
log.Info("Ignoring duplicate: %v", peer)
|
|
return nil, ErrSwitchDuplicatePeer
|
|
}
|
|
|
|
// Start the peer
|
|
go peer.start()
|
|
|
|
// Notify listeners.
|
|
s.emit(SwitchEventNewPeer{Peer: peer})
|
|
|
|
return peer, nil
|
|
}
|
|
|
|
func (s *Switch) DialPeerWithAddress(addr *NetAddress) (*Peer, error) {
|
|
if atomic.LoadUint32(&s.stopped) == 1 {
|
|
return nil, ErrSwitchStopped
|
|
}
|
|
|
|
log.Info("Dialing peer @ %v", addr)
|
|
s.dialing.Set(addr.String(), addr)
|
|
conn, err := addr.DialTimeout(peerDialTimeoutSeconds * time.Second)
|
|
s.dialing.Delete(addr.String())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
peer, err := s.AddPeerWithConnection(conn, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return peer, nil
|
|
}
|
|
|
|
func (s *Switch) IsDialing(addr *NetAddress) bool {
|
|
return s.dialing.Has(addr.String())
|
|
}
|
|
|
|
func (s *Switch) Broadcast(chId byte, msg Binary) (numSuccess, numFailure int) {
|
|
if atomic.LoadUint32(&s.stopped) == 1 {
|
|
return
|
|
}
|
|
|
|
msgBytes := BinaryBytes(msg)
|
|
|
|
log.Debug("Broadcast on [%X] len: %v", chId, len(msgBytes))
|
|
for _, peer := range s.peers.List() {
|
|
success := peer.TrySend(chId, msgBytes)
|
|
log.Debug("Broadcast for peer %v success: %v", peer, success)
|
|
if success {
|
|
numSuccess += 1
|
|
} else {
|
|
numFailure += 1
|
|
}
|
|
}
|
|
return
|
|
|
|
}
|
|
|
|
// The events are of type SwitchEvent* defined below.
|
|
// Switch does not close these listeners.
|
|
func (s *Switch) AddEventListener(name string, listener chan<- interface{}) {
|
|
s.listeners.Set(name, listener)
|
|
}
|
|
|
|
func (s *Switch) RemoveEventListener(name string) {
|
|
s.listeners.Delete(name)
|
|
}
|
|
|
|
/*
|
|
Receive blocks on a channel until a message is found.
|
|
*/
|
|
func (s *Switch) Receive(chId byte) (InboundBytes, bool) {
|
|
if atomic.LoadUint32(&s.stopped) == 1 {
|
|
return InboundBytes{}, false
|
|
}
|
|
|
|
q := s.recvQueues[chId]
|
|
if q == nil {
|
|
Panicf("Expected recvQueues[%X], found none", chId)
|
|
}
|
|
|
|
select {
|
|
case <-s.quit:
|
|
return InboundBytes{}, false
|
|
case inBytes := <-q:
|
|
log.Debug("RECV %v", inBytes)
|
|
return inBytes, true
|
|
}
|
|
}
|
|
|
|
// Returns the count of outbound/inbound and outbound-dialing peers.
|
|
func (s *Switch) NumPeers() (outbound, inbound, dialing int) {
|
|
peers := s.peers.List()
|
|
for _, peer := range peers {
|
|
if peer.outbound {
|
|
outbound++
|
|
} else {
|
|
inbound++
|
|
}
|
|
}
|
|
dialing = s.dialing.Size()
|
|
return
|
|
}
|
|
|
|
func (s *Switch) Peers() IPeerSet {
|
|
return s.peers
|
|
}
|
|
|
|
// Disconnect from a peer due to external error.
|
|
// TODO: make record depending on reason.
|
|
func (s *Switch) StopPeerForError(peer *Peer, reason interface{}) {
|
|
log.Info("- %v !! reason: %v", peer, reason)
|
|
s.peers.Remove(peer)
|
|
peer.stop()
|
|
|
|
// Notify listeners
|
|
s.emit(SwitchEventDonePeer{Peer: peer, Error: reason})
|
|
}
|
|
|
|
// Disconnect from a peer gracefully.
|
|
// TODO: handle graceful disconnects.
|
|
func (s *Switch) StopPeerGracefully(peer *Peer) {
|
|
log.Info("- %v", peer)
|
|
s.peers.Remove(peer)
|
|
peer.stop()
|
|
|
|
// Notify listeners
|
|
s.emit(SwitchEventDonePeer{Peer: peer})
|
|
}
|
|
|
|
func (s *Switch) emit(event interface{}) {
|
|
for _, ch_i := range s.listeners.Values() {
|
|
ch := ch_i.(chan<- interface{})
|
|
ch <- event
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type SwitchEventNewPeer struct {
|
|
Peer *Peer
|
|
}
|
|
|
|
type SwitchEventDonePeer struct {
|
|
Peer *Peer
|
|
Error interface{}
|
|
}
|