path: root/peer.go

package main

import (
    "github.com/ethereum/ethwire-go"
    "log"
    "net"
)

type Peer struct {
    // Server interface
    server *Server
    // Net connection
    conn net.Conn
    // Output queue which is used to communicate and handle messages
    outputQueue chan ethwire.InOutMsg
    // Quit channel
    quit chan bool
}

func NewPeer(conn net.Conn, server *Server) *Peer {
    return &Peer{
        outputQueue: make(chan ethwire.InOutMsg, 1), // Buffered chan of 1 is enough
        quit:        make(chan bool),

        server: server,
        conn:   conn,
    }
}

// Outputs any RLP encoded data to the peer
func (p *Peer) QueueMessage(msgType string, data []byte) {
    p.outputQueue <- ethwire.InOutMsg{MsgType: msgType, Data: data}
}

// Outbound message handler. Outbound messages are handled here
func (p *Peer) HandleOutbound() {
out:
    for {
        select {
        // Main message queue. All outbound messages are processed through here
        case msg := <-p.outputQueue:
            // TODO Message checking and handle accordingly
            err := ethwire.WriteMessage(p.conn, msg)
            if err != nil {
                log.Println(err)

                // Stop the client if there was an error writing to it
                p.Stop()
            }

        // Break out of the for loop if a quit message is posted
        case <-p.quit:
            break out
        }
    }
}

// Inbound handler. Inbound messages are received here and passed to the appropriate methods
func (p *Peer) HandleInbound() {
    defer p.Stop()

out:
    for {
        // Wait for a message from the peer
        msg, err := ethwire.ReadMessage(p.conn)
        if err != nil {
            log.Println(err)

            break out
        }

        // TODO
        data, _ := Decode(msg.Data, 0)
        log.Printf("%s, %s\n", msg.MsgType, data)
    }

    // Notify the out handler we're quiting
    p.quit <- true
}

func (p *Peer) Start() {
    // Run the outbound handler in a new goroutine
    go p.HandleOutbound()
    // Run the inbound handler in a new goroutine
    go p.HandleInbound()
}

func (p *Peer) Stop() {
    p.conn.Close()

    p.quit <- true
}