|
|
- package peer
-
- import (
- "errors"
- "sync"
- "sync/atomic"
-
- . "github.com/tendermint/tendermint/binary"
- . "github.com/tendermint/tendermint/common"
- "github.com/tendermint/tendermint/merkle"
- )
-
- /* Client
-
- A client is half of a p2p system.
- It can reach out to the network and establish connections with servers.
- A client doesn't listen for incoming connections -- that's done by the server.
-
- makePeerFn is a factory method for generating new peers from new *Connections.
- makePeerFn(nil) must return a prototypical peer that represents the self "peer".
-
- XXX what about peer disconnects?
- */
- type Client struct {
- addrBook *AddrBook
- targetNumPeers int
- makePeerFn func(*Connection) *Peer
- self *Peer
- recvQueues map[String]chan *InboundPacket
-
- mtx sync.Mutex
- peers merkle.Tree // addr -> *Peer
- quit chan struct{}
- stopped uint32
- }
-
- var (
- CLIENT_STOPPED_ERROR = errors.New("Client already stopped")
- CLIENT_DUPLICATE_PEER_ERROR = errors.New("Duplicate peer")
- )
-
- func NewClient(makePeerFn func(*Connection) *Peer) *Client {
- self := makePeerFn(nil)
- if self == nil {
- Panicf("makePeerFn(nil) must return a prototypical peer for self")
- }
-
- recvQueues := make(map[String]chan *InboundPacket)
- for chName, _ := range self.channels {
- recvQueues[chName] = make(chan *InboundPacket)
- }
-
- c := &Client{
- addrBook: nil, // TODO
- targetNumPeers: 0, // TODO
- makePeerFn: makePeerFn,
- self: self,
- recvQueues: recvQueues,
-
- peers: merkle.NewIAVLTree(nil),
- quit: make(chan struct{}),
- stopped: 0,
- }
- return c
- }
-
- func (c *Client) Stop() {
- log.Infof("Stopping client")
- // lock
- c.mtx.Lock()
- if atomic.CompareAndSwapUint32(&c.stopped, 0, 1) {
- close(c.quit)
- // stop each peer.
- for peerValue := range c.peers.Values() {
- peer := peerValue.(*Peer)
- peer.Stop()
- }
- // empty tree.
- c.peers = merkle.NewIAVLTree(nil)
- }
- c.mtx.Unlock()
- // unlock
- }
-
- func (c *Client) AddPeerWithConnection(conn *Connection, outgoing bool) (*Peer, error) {
- if atomic.LoadUint32(&c.stopped) == 1 {
- return nil, CLIENT_STOPPED_ERROR
- }
-
- log.Infof("Adding peer with connection: %v, outgoing: %v", conn, outgoing)
- peer := c.makePeerFn(conn)
- peer.outgoing = outgoing
- err := c.addPeer(peer)
- if err != nil {
- return nil, err
- }
-
- go peer.Start(c.recvQueues)
-
- return peer, nil
- }
-
- func (c *Client) Broadcast(pkt Packet) (numSuccess, numFailure int) {
- if atomic.LoadUint32(&c.stopped) == 1 {
- return
- }
-
- log.Tracef("Broadcast on [%v] len: %v", pkt.Channel, len(pkt.Bytes))
- for v := range c.peers.Values() {
- peer := v.(*Peer)
- success := peer.TrySend(pkt)
- log.Tracef("Broadcast for peer %v success: %v", peer, success)
- if success {
- numSuccess += 1
- } else {
- numFailure += 1
- }
- }
- return
-
- }
-
- // blocks until a message is popped.
- func (c *Client) Receive(chName String) *InboundPacket {
- if atomic.LoadUint32(&c.stopped) == 1 {
- return nil
- }
-
- log.Tracef("Receive on [%v]", chName)
- q := c.recvQueues[chName]
- if q == nil {
- Panicf("Expected recvQueues[%f], found none", chName)
- }
-
- select {
- case <-c.quit:
- return nil
- case inPacket := <-q:
- return inPacket
- }
- }
-
- func (c *Client) Peers() merkle.Tree {
- // lock & defer
- c.mtx.Lock()
- defer c.mtx.Unlock()
- return c.peers.Copy()
- // unlock deferred
- }
-
- func (c *Client) StopPeer(peer *Peer) {
- // lock
- c.mtx.Lock()
- peerValue, _ := c.peers.Remove(peer.RemoteAddress())
- c.mtx.Unlock()
- // unlock
-
- peer_ := peerValue.(*Peer)
- if peer_ != nil {
- peer_.Stop()
- }
- }
-
- func (c *Client) addPeer(peer *Peer) error {
- addr := peer.RemoteAddress()
-
- // lock & defer
- c.mtx.Lock()
- defer c.mtx.Unlock()
- if c.stopped == 1 {
- return CLIENT_STOPPED_ERROR
- }
- if !c.peers.Has(addr) {
- log.Tracef("Actually putting addr: %v, peer: %v", addr, peer)
- c.peers.Put(addr, peer)
- return nil
- } else {
- // ignore duplicate peer for addr.
- log.Infof("Ignoring duplicate peer for addr %v", addr)
- return CLIENT_DUPLICATE_PEER_ERROR
- }
- // unlock deferred
- }
|