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.
269 lines
5.6 KiB
269 lines
5.6 KiB
package p2p
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
. "github.com/tendermint/tendermint/binary"
|
|
)
|
|
|
|
/* Peer */
|
|
|
|
type Peer struct {
|
|
outbound bool
|
|
conn *Connection
|
|
channels map[string]*Channel
|
|
quit chan struct{}
|
|
started uint32
|
|
stopped uint32
|
|
}
|
|
|
|
func newPeer(conn *Connection, channels map[string]*Channel) *Peer {
|
|
return &Peer{
|
|
conn: conn,
|
|
channels: channels,
|
|
quit: make(chan struct{}),
|
|
stopped: 0,
|
|
}
|
|
}
|
|
|
|
func (p *Peer) start(pktRecvQueues map[string]chan *InboundPacket, onPeerError func(*Peer, interface{})) {
|
|
log.Debugf("Starting %v", p)
|
|
|
|
if atomic.CompareAndSwapUint32(&p.started, 0, 1) {
|
|
// on connection error
|
|
onError := func(r interface{}) {
|
|
p.stop()
|
|
onPeerError(p, r)
|
|
}
|
|
p.conn.Start(p.channels, onError)
|
|
for chName, _ := range p.channels {
|
|
chInQueue := pktRecvQueues[chName]
|
|
go p.recvHandler(chName, chInQueue)
|
|
go p.sendHandler(chName)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *Peer) stop() {
|
|
if atomic.CompareAndSwapUint32(&p.stopped, 0, 1) {
|
|
log.Debugf("Stopping %v", p)
|
|
close(p.quit)
|
|
p.conn.Stop()
|
|
}
|
|
}
|
|
|
|
func (p *Peer) IsOutbound() bool {
|
|
return p.outbound
|
|
}
|
|
|
|
func (p *Peer) LocalAddress() *NetAddress {
|
|
return p.conn.LocalAddress()
|
|
}
|
|
|
|
func (p *Peer) RemoteAddress() *NetAddress {
|
|
return p.conn.RemoteAddress()
|
|
}
|
|
|
|
func (p *Peer) Channel(chName string) *Channel {
|
|
return p.channels[chName]
|
|
}
|
|
|
|
// TrySend returns true if the packet was successfully queued.
|
|
// Returning true does not imply that the packet will be sent.
|
|
func (p *Peer) TrySend(pkt Packet) bool {
|
|
log.Debugf("TrySend [%v] -> %v", pkt, p)
|
|
channel := p.Channel(string(pkt.Channel))
|
|
sendQueue := channel.sendQueue
|
|
|
|
if atomic.LoadUint32(&p.stopped) == 1 {
|
|
return false
|
|
}
|
|
|
|
select {
|
|
case sendQueue <- pkt:
|
|
return true
|
|
default: // buffer full
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (p *Peer) Send(pkt Packet) bool {
|
|
log.Debugf("Send [%v] -> %v", pkt, p)
|
|
channel := p.Channel(string(pkt.Channel))
|
|
sendQueue := channel.sendQueue
|
|
|
|
if atomic.LoadUint32(&p.stopped) == 1 {
|
|
return false
|
|
}
|
|
|
|
sendQueue <- pkt
|
|
return true
|
|
}
|
|
|
|
func (p *Peer) WriteTo(w io.Writer) (n int64, err error) {
|
|
return p.RemoteAddress().WriteTo(w)
|
|
}
|
|
|
|
func (p *Peer) String() string {
|
|
return fmt.Sprintf("Peer{%v-%v,o:%v}", p.LocalAddress(), p.RemoteAddress(), p.outbound)
|
|
}
|
|
|
|
// sendHandler pulls from a channel and pushes to the connection.
|
|
// Each channel gets its own sendHandler goroutine;
|
|
// Golang's channel implementation handles the scheduling.
|
|
func (p *Peer) sendHandler(chName string) {
|
|
log.Tracef("%v sendHandler [%v]", p, chName)
|
|
channel := p.channels[chName]
|
|
sendQueue := channel.sendQueue
|
|
FOR_LOOP:
|
|
for {
|
|
select {
|
|
case <-p.quit:
|
|
break FOR_LOOP
|
|
case pkt := <-sendQueue:
|
|
log.Tracef("Sending packet to peer sendQueue")
|
|
// blocks until the connection is Stop'd,
|
|
// which happens when this peer is Stop'd.
|
|
p.conn.Send(pkt)
|
|
}
|
|
}
|
|
|
|
log.Tracef("%v sendHandler [%v] closed", p, chName)
|
|
// cleanup
|
|
// (none)
|
|
}
|
|
|
|
// recvHandler pulls from a channel and pushes to the given pktRecvQueue.
|
|
// Each channel gets its own recvHandler goroutine.
|
|
// Many peers have goroutines that push to the same pktRecvQueue.
|
|
// Golang's channel implementation handles the scheduling.
|
|
func (p *Peer) recvHandler(chName string, pktRecvQueue chan<- *InboundPacket) {
|
|
log.Tracef("%v recvHandler [%v]", p, chName)
|
|
channel := p.channels[chName]
|
|
recvQueue := channel.recvQueue
|
|
|
|
FOR_LOOP:
|
|
for {
|
|
select {
|
|
case <-p.quit:
|
|
break FOR_LOOP
|
|
case pkt := <-recvQueue:
|
|
// send to pktRecvQueue
|
|
inboundPacket := &InboundPacket{
|
|
Peer: p,
|
|
Time: Time{time.Now()},
|
|
Packet: pkt,
|
|
}
|
|
select {
|
|
case <-p.quit:
|
|
break FOR_LOOP
|
|
case pktRecvQueue <- inboundPacket:
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
log.Tracef("%v recvHandler [%v] closed", p, chName)
|
|
// cleanup
|
|
// (none)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/* ChannelDescriptor */
|
|
|
|
type ChannelDescriptor struct {
|
|
Name string
|
|
SendBufferSize int
|
|
RecvBufferSize int
|
|
}
|
|
|
|
/* Channel */
|
|
|
|
type Channel struct {
|
|
name string
|
|
recvQueue chan Packet
|
|
sendQueue chan Packet
|
|
//stats Stats
|
|
}
|
|
|
|
func newChannel(desc ChannelDescriptor) *Channel {
|
|
return &Channel{
|
|
name: desc.Name,
|
|
recvQueue: make(chan Packet, desc.RecvBufferSize),
|
|
sendQueue: make(chan Packet, desc.SendBufferSize),
|
|
}
|
|
}
|
|
|
|
func (c *Channel) Name() string {
|
|
return c.name
|
|
}
|
|
|
|
func (c *Channel) RecvQueue() <-chan Packet {
|
|
return c.recvQueue
|
|
}
|
|
|
|
func (c *Channel) SendQueue() chan<- Packet {
|
|
return c.sendQueue
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*
|
|
Packet encapsulates a ByteSlice on a Channel.
|
|
*/
|
|
type Packet struct {
|
|
Channel String
|
|
Bytes ByteSlice
|
|
// Hash
|
|
}
|
|
|
|
func NewPacket(chName String, msg Binary) Packet {
|
|
msgBytes := BinaryBytes(msg)
|
|
log.Tracef("NewPacket msg bytes: %X", msgBytes)
|
|
return Packet{
|
|
Channel: chName,
|
|
Bytes: msgBytes,
|
|
}
|
|
}
|
|
|
|
func (p Packet) WriteTo(w io.Writer) (n int64, err error) {
|
|
n, err = WriteOnto(p.Channel, w, n, err)
|
|
n, err = WriteOnto(p.Bytes, w, n, err)
|
|
return
|
|
}
|
|
|
|
func (p Packet) Reader() io.Reader {
|
|
return bytes.NewReader(p.Bytes)
|
|
}
|
|
|
|
func (p Packet) String() string {
|
|
return fmt.Sprintf("%v:%X", p.Channel, p.Bytes)
|
|
}
|
|
|
|
func ReadPacketSafe(r io.Reader) (pkt Packet, err error) {
|
|
chName, err := ReadStringSafe(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// TODO: packet length sanity check.
|
|
bytes, err := ReadByteSliceSafe(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
log.Tracef("ReadPacket* msg bytes: %X", bytes)
|
|
return Packet{Channel: chName, Bytes: bytes}, nil
|
|
}
|
|
|
|
/*
|
|
InboundPacket extends Packet with fields relevant to inbound packets.
|
|
*/
|
|
type InboundPacket struct {
|
|
Peer *Peer
|
|
Time Time
|
|
Packet
|
|
}
|