gofmt no coding standards

peer.go

@@ -1,92 +1,92 @@
 package main
 
 import (
-  "net"
-  "log"
-  "github.com/ethereum/ethwire-go"
+	"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
+	// 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),
+	return &Peer{
+		outputQueue: make(chan ethwire.InOutMsg, 1), // Buffered chan of 1 is enough
+		quit:        make(chan bool),
 
-    server:            server,
-    conn:              conn,
-  }
+		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}
+	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)
+	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()
-      }
+				// 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
-    }
-  }
+		// 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()
+	defer p.Stop()
 
 out:
-  for {
-    // Wait for a message from the peer
-    msg, err := ethwire.ReadMessage(p.conn)
-    if err != nil {
-      log.Println(err)
+	for {
+		// Wait for a message from the peer
+		msg, err := ethwire.ReadMessage(p.conn)
+		if err != nil {
+			log.Println(err)
 
-      break out
-    }
+			break out
+		}
 
-    // TODO
-    data, _ := Decode(msg.Data, 0)
-    log.Printf("%s, %s\n", msg.MsgType, data)
-  }
+		// TODO
+		data, _ := Decode(msg.Data, 0)
+		log.Printf("%s, %s\n", msg.MsgType, data)
+	}
 
-  // Notify the out handler we're quiting
-  p.quit <- true
+	// 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()
+	// 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.conn.Close()
 
-  p.quit <- true
+	p.quit <- true
 }