From f6fa4f88797030b8e83066cb262a68958953974e Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Fri, 10 Jan 2014 21:18:56 +0100
Subject: [PATCH] WIP Splitting ethereum up in submodules

---
 block.go | 20 ++++++++++++----
 peer.go  | 69 ++++++++++++--------------------------------------------
 2 files changed, 30 insertions(+), 59 deletions(-)

diff --git a/block.go b/block.go
index 6ae3cc832a..2287a9d559 100644
--- a/block.go
+++ b/block.go
@@ -51,7 +51,15 @@ func CreateTestBlock(/* TODO use raw data */transactions []*Transaction) *Block
   return block
 }
 
-func CreateBlock(root string, num int, prevHash string, base string, difficulty int, nonce int, extra string, txes []*Transaction) *Block {
+func CreateBlock(root string,
+                  num int,
+                  prevHash string,
+                  base string,
+                  difficulty int,
+                  nonce int,
+                  extra string,
+                  txes []*Transaction) *Block {
+
   block := &Block{
     // Slice of transactions to include in this block
     transactions: txes,
@@ -134,8 +142,11 @@ func (block *Block) MarshalRlp() []byte {
     // Cast it to a string (safe)
     encTx[i] = string(tx.MarshalRlp())
   }
+  // TODO
+  uncles := []interface{}{}
 
-  /* I made up the block. It should probably contain different data or types. It sole purpose now is testing */
+  // I made up the block. It should probably contain different data or types.
+  // It sole purpose now is testing
   header := []interface{}{
     block.number,
     block.prevHash,
@@ -152,9 +163,8 @@ func (block *Block) MarshalRlp() []byte {
     block.extra,
   }
 
-  // TODO
-  uncles := []interface{}{}
-  // Encode a slice interface which contains the header and the list of transactions.
+  // Encode a slice interface which contains the header and the list of
+  // transactions.
   return Encode([]interface{}{header, encTx, uncles})
 }
 
diff --git a/peer.go b/peer.go
index a855fe2b9f..d47af73deb 100644
--- a/peer.go
+++ b/peer.go
@@ -2,57 +2,24 @@ package main
 
 import (
   "net"
-  "errors"
   "log"
+  "github.com/ethereum/ethwire-go"
 )
 
-type InMsg struct {
-  msgType   string  // Specifies how the encoded data should be interpreted
-  data      []byte  // RLP encoded data
-}
-
-type OutMsg struct {
-  msgType   string
-  data      []byte
-}
-
-func ReadMessage(conn net.Conn) (*InMsg, error) {
-  buff := make([]byte, 4069)
-
-  // Wait for a message from this peer
-  n, err := conn.Read(buff)
-  if err != nil {
-    return nil, err
-  } else if n == 0 {
-    return nil, errors.New("Empty message received")
-  }
-
-  // Read the header (MAX n)
-  // XXX The data specification is made up. This will change once more details have been released on the specification of the format
-  decoder := NewRlpDecoder(buff[:n])
-  t := decoder.Get(0).AsString()
-  // If the msgdata contains no data we throw an error and disconnect the peer
-  if t == "" {
-    return nil, errors.New("Data contained no data type")
-  }
-
-  return &InMsg{msgType: t, data: decoder.Get(1).AsBytes()}, nil
-}
-
 type Peer struct {
   // Server interface
   server      *Server
   // Net connection
   conn        net.Conn
   // Output queue which is used to communicate and handle messages
-  outputQueue chan OutMsg
+  outputQueue chan ethwire.InOutMsg
   // Quit channel
   quit        chan bool
 }
 
 func NewPeer(conn net.Conn, server *Server) *Peer {
   return &Peer{
-    outputQueue:       make(chan OutMsg, 1),  // Buffered chan of 1 is enough
+    outputQueue:       make(chan ethwire.InOutMsg, 1),  // Buffered chan of 1 is enough
     quit:              make(chan bool),
 
     server:            server,
@@ -62,7 +29,7 @@ func NewPeer(conn net.Conn, server *Server) *Peer {
 
 // Outputs any RLP encoded data to the peer
 func (p *Peer) QueueMessage(msgType string, data []byte) {
-  p.outputQueue <- OutMsg{msgType: msgType, data: data}
+  p.outputQueue <- ethwire.InOutMsg{MsgType: msgType, Data: data}
 }
 
 // Outbound message handler. Outbound messages are handled here
@@ -73,7 +40,13 @@ out:
     // Main message queue. All outbound messages are processed through here
     case msg := <-p.outputQueue:
       // TODO Message checking and handle accordingly
-      p.WriteMessage(msg)
+      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:
@@ -82,18 +55,6 @@ out:
   }
 }
 
-// Write a message to the peer.
-func (p *Peer) WriteMessage(msg OutMsg) {
-  // Encode the type and the (RLP encoded) data for sending over the wire
-  encoded := Encode([]interface{}{ msg.msgType, msg.data })
-  // Write to the connection
-  _, err := p.conn.Write(encoded)
-  if err != nil {
-    log.Println(err)
-    p.Stop()
-  }
-}
-
 // Inbound handler. Inbound messages are received here and passed to the appropriate methods
 func (p *Peer) HandleInbound() {
   defer p.Stop()
@@ -101,7 +62,7 @@ func (p *Peer) HandleInbound() {
 out:
   for {
     // Wait for a message from the peer
-    msg, err := ReadMessage(p.conn)
+    msg, err := ethwire.ReadMessage(p.conn)
     if err != nil {
       log.Println(err)
 
@@ -109,8 +70,8 @@ out:
     }
 
     // TODO
-    data, _ := Decode(msg.data, 0)
-    log.Printf("%s, %s\n", msg.msgType, data)
+    data, _ := Decode(msg.Data, 0)
+    log.Printf("%s, %s\n", msg.MsgType, data)
   }
 
   // Notify the out handler we're quiting
@@ -125,7 +86,7 @@ func (p *Peer) Start() {
 }
 
 func (p *Peer) Stop() {
-  defer p.conn.Close()
+  p.conn.Close()
 
   p.quit <- true
 }