go fmt

ethchain/block_chain.go

@@ -2,9 +2,9 @@ package ethchain
 
 import (
 	"bytes"
+	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethwire"
-	"github.com/ethereum/eth-go/ethlog"
 	"math"
 	"math/big"
 )

ethchain/dagger.go

 package ethchain
 
 import (
-	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
 	"github.com/obscuren/sha3"
 	"hash"
 	"math/big"
@@ -31,7 +31,6 @@ func (pow *EasyPow) Search(block *Block, reactChan chan ethutil.React) []byte {
 	for {
 		select {
 		case <-reactChan:
-			//powlogger.Infoln("Received reactor event; breaking out.")
 			return nil
 		default:
 			i++

ethchain/state_manager.go

@@ -3,9 +3,9 @@ package ethchain
 import (
 	"bytes"
 	"container/list"
+	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethwire"
-	"github.com/ethereum/eth-go/ethlog"
 	"math/big"
 	"sync"
 	"time"

ethchain/transaction_pool.go

@@ -4,8 +4,8 @@ import (
 	"bytes"
 	"container/list"
 	"fmt"
-	"github.com/ethereum/eth-go/ethwire"
 	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethwire"
 	"math/big"
 	"sync"
 )

ethchain/vm.go

@@ -2,8 +2,8 @@ package ethchain
 
 import (
 	"fmt"
-	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
 	"math"
 	"math/big"
 )

ethereum.go

@@ -5,10 +5,10 @@ import (
 	"fmt"
 	"github.com/ethereum/eth-go/ethchain"
 	"github.com/ethereum/eth-go/ethdb"
+	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethrpc"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethwire"
-	"github.com/ethereum/eth-go/ethlog"
 	"io/ioutil"
 	"math/rand"
 	"net"

ethlog/loggers.go

 package ethlog
 
 import (
-  "fmt"
-  "sync"
-  "log"
-  "io"
-  "os"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"sync"
 )
 
 type LogSystem interface {
-  GetLogLevel() LogLevel
-  SetLogLevel(i LogLevel)
-  Println(v ...interface{})
-  Printf(format string, v ...interface{})
+	GetLogLevel() LogLevel
+	SetLogLevel(i LogLevel)
+	Println(v ...interface{})
+	Printf(format string, v ...interface{})
 }
 
 type logMessage struct {
-  LogLevel  LogLevel
-  format    bool
-  msg       string
+	LogLevel LogLevel
+	format   bool
+	msg      string
 }
 
-func newPrintlnLogMessage(level LogLevel, tag string, v...interface{}) *logMessage {
-  return &logMessage{level, false, fmt.Sprintf("[%s] %s", tag, fmt.Sprint(v...))}
+func newPrintlnLogMessage(level LogLevel, tag string, v ...interface{}) *logMessage {
+	return &logMessage{level, false, fmt.Sprintf("[%s] %s", tag, fmt.Sprint(v...))}
 }
 
-func newPrintfLogMessage(level LogLevel, tag string, format string, v...interface{}) *logMessage {
-  return &logMessage{level, true, fmt.Sprintf("[%s] %s", tag, fmt.Sprintf(format, v...))}
+func newPrintfLogMessage(level LogLevel, tag string, format string, v ...interface{}) *logMessage {
+	return &logMessage{level, true, fmt.Sprintf("[%s] %s", tag, fmt.Sprintf(format, v...))}
 }
 
 func (msg *logMessage) send(logger LogSystem) {
-  if msg.format {
-    logger.Printf(msg.msg)
-  } else {
-    logger.Println(msg.msg)
-  }
+	if msg.format {
+		logger.Printf(msg.msg)
+	} else {
+		logger.Println(msg.msg)
+	}
 }
 
-var logMessages chan(*logMessage)
-var logSystems  []LogSystem
+var logMessages chan (*logMessage)
+var logSystems []LogSystem
 var drained = true
 
 type LogLevel uint8
 
 const (
-  Silence LogLevel = iota
-  ErrorLevel
-  WarnLevel
-  InfoLevel
-  DebugLevel
-  DebugDetailLevel
+	Silence LogLevel = iota
+	ErrorLevel
+	WarnLevel
+	InfoLevel
+	DebugLevel
+	DebugDetailLevel
 )
 
 // log messages are dispatched to log writers
 func start() {
-  for {
-    select {
-      case msg := <- logMessages:
-        for _, logSystem := range logSystems {
-          if logSystem.GetLogLevel() >= msg.LogLevel {
-            msg.send(logSystem)
-          }
-        }
-      default:
-        drained = true
-    }
-  }
+	for {
+		select {
+		case msg := <-logMessages:
+			for _, logSystem := range logSystems {
+				if logSystem.GetLogLevel() >= msg.LogLevel {
+					msg.send(logSystem)
+				}
+			}
+		default:
+			drained = true
+		}
+	}
 }
 
 // waits until log messages are drained (dispatched to log writers)
 func Flush() {
-  for !drained {}
+	for !drained {
+	}
 }
 
 type Logger struct {
-  tag string
+	tag string
 }
 
 func NewLogger(tag string) *Logger {
-  return &Logger{tag}
+	return &Logger{tag}
 }
 
 func AddLogSystem(logSystem LogSystem) {
-  var mutex = &sync.Mutex{}
-  mutex.Lock()
-  defer mutex.Unlock()
-  if logSystems == nil {
-    logMessages = make(chan *logMessage)
-    go start()
-  }
-  logSystems = append(logSystems, logSystem)
+	var mutex = &sync.Mutex{}
+	mutex.Lock()
+	defer mutex.Unlock()
+	if logSystems == nil {
+		logMessages = make(chan *logMessage)
+		go start()
+	}
+	logSystems = append(logSystems, logSystem)
 }
 
-func (logger *Logger) sendln(level LogLevel, v...interface{}) {
-  if logMessages != nil {
-    msg := newPrintlnLogMessage(level, logger.tag, v...)
-    drained = false
-    logMessages <- msg
-  }
+func (logger *Logger) sendln(level LogLevel, v ...interface{}) {
+	if logMessages != nil {
+		msg := newPrintlnLogMessage(level, logger.tag, v...)
+		drained = false
+		logMessages <- msg
+	}
 }
 
-func (logger *Logger) sendf(level LogLevel, format string, v...interface{}) {
-  if logMessages != nil {
-    msg := newPrintfLogMessage(level, logger.tag, format, v...)
-    drained = false
-    logMessages <- msg
-  }
+func (logger *Logger) sendf(level LogLevel, format string, v ...interface{}) {
+	if logMessages != nil {
+		msg := newPrintfLogMessage(level, logger.tag, format, v...)
+		drained = false
+		logMessages <- msg
+	}
 }
 
-func (logger *Logger) Errorln(v...interface{}) {
-  logger.sendln(ErrorLevel, v...)
+func (logger *Logger) Errorln(v ...interface{}) {
+	logger.sendln(ErrorLevel, v...)
 }
 
-func (logger *Logger) Warnln(v...interface{}) {
-  logger.sendln(WarnLevel, v...)
+func (logger *Logger) Warnln(v ...interface{}) {
+	logger.sendln(WarnLevel, v...)
 }
 
-func (logger *Logger) Infoln(v...interface{}) {
-  logger.sendln(InfoLevel, v...)
+func (logger *Logger) Infoln(v ...interface{}) {
+	logger.sendln(InfoLevel, v...)
 }
 
-func (logger *Logger) Debugln(v...interface{}) {
-  logger.sendln(DebugLevel, v...)
+func (logger *Logger) Debugln(v ...interface{}) {
+	logger.sendln(DebugLevel, v...)
 }
 
-func (logger *Logger) DebugDetailln(v...interface{}) {
-  logger.sendln(DebugDetailLevel, v...)
+func (logger *Logger) DebugDetailln(v ...interface{}) {
+	logger.sendln(DebugDetailLevel, v...)
 }
 
-func (logger *Logger) Errorf(format string, v...interface{}) {
-  logger.sendf(ErrorLevel, format, v...)
+func (logger *Logger) Errorf(format string, v ...interface{}) {
+	logger.sendf(ErrorLevel, format, v...)
 }
 
-func (logger *Logger) Warnf(format string, v...interface{}) {
-  logger.sendf(WarnLevel, format, v...)
+func (logger *Logger) Warnf(format string, v ...interface{}) {
+	logger.sendf(WarnLevel, format, v...)
 }
 
-func (logger *Logger) Infof(format string, v...interface{}) {
-  logger.sendf(InfoLevel, format, v...)
+func (logger *Logger) Infof(format string, v ...interface{}) {
+	logger.sendf(InfoLevel, format, v...)
 }
 
-func (logger *Logger) Debugf(format string, v...interface{}) {
-  logger.sendf(DebugLevel, format, v...)
+func (logger *Logger) Debugf(format string, v ...interface{}) {
+	logger.sendf(DebugLevel, format, v...)
 }
 
-func (logger *Logger) DebugDetailf(format string, v...interface{}) {
-  logger.sendf(DebugDetailLevel, format, v...)
+func (logger *Logger) DebugDetailf(format string, v ...interface{}) {
+	logger.sendf(DebugDetailLevel, format, v...)
 }
 
-func (logger *Logger) Fatalln (v...interface{}) {
-  logger.sendln(ErrorLevel, v...)
-  Flush()
-  os.Exit(0)
+func (logger *Logger) Fatalln(v ...interface{}) {
+	logger.sendln(ErrorLevel, v...)
+	Flush()
+	os.Exit(0)
 }
 
-func (logger *Logger) Fatalf (format string, v...interface{}) {
-  logger.sendf(ErrorLevel, format, v...)
-  Flush()
-  os.Exit(0)
+func (logger *Logger) Fatalf(format string, v ...interface{}) {
+	logger.sendf(ErrorLevel, format, v...)
+	Flush()
+	os.Exit(0)
 }
 
 type StdLogSystem struct {
-  logger *log.Logger
-  level LogLevel
+	logger *log.Logger
+	level  LogLevel
 }
 
 func (t *StdLogSystem) Println(v ...interface{}) {
-  t.logger.Println(v...)
+	t.logger.Println(v...)
 }
 
 func (t *StdLogSystem) Printf(format string, v ...interface{}) {
-  t.logger.Printf(format, v...)
+	t.logger.Printf(format, v...)
 }
 
 func (t *StdLogSystem) SetLogLevel(i LogLevel) {
-  t.level = i
+	t.level = i
 }
 
 func (t *StdLogSystem) GetLogLevel() LogLevel {
-  return t.level
+	return t.level
 }
 
 func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) *StdLogSystem {
-  logger := log.New(writer, "", flags)
-  return &StdLogSystem{logger, level}
+	logger := log.New(writer, "", flags)
+	return &StdLogSystem{logger, level}
 }
-

ethlog/loggers_test.go

 package ethlog
 
 import (
-  "testing"
-  "fmt"
-  "io/ioutil"
-  "os"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"testing"
 )
 
 type TestLogSystem struct {
-  Output string
-  level  LogLevel
+	Output string
+	level  LogLevel
 }
 
 func (t *TestLogSystem) Println(v ...interface{}) {
-  t.Output += fmt.Sprintln(v...)
+	t.Output += fmt.Sprintln(v...)
 }
 
 func (t *TestLogSystem) Printf(format string, v ...interface{}) {
-  t.Output += fmt.Sprintf(format, v...)
+	t.Output += fmt.Sprintf(format, v...)
 }
 
 func (t *TestLogSystem) SetLogLevel(i LogLevel) {
-  t.level = i
+	t.level = i
 }
 
 func (t *TestLogSystem) GetLogLevel() LogLevel {
-  return t.level
+	return t.level
 }
 
 func quote(s string) string {
-  return fmt.Sprintf("'%s'", s)
+	return fmt.Sprintf("'%s'", s)
 }
 
 func TestLoggerPrintln(t *testing.T) {
-  logger := NewLogger("TEST")
-  testLogSystem := &TestLogSystem{level: WarnLevel}
-  AddLogSystem(testLogSystem)
-  logger.Errorln("error")
-  logger.Warnln("warn")
-  logger.Infoln("info")
-  logger.Debugln("debug")
-  Flush()
-  output := testLogSystem.Output
-  fmt.Println(quote(output))
-  if output != "[TEST] error\n[TEST] warn\n" {
-    t.Error("Expected logger output '[TEST] error\\n[TEST] warn\\n', got ", quote(testLogSystem.Output))
-  }
+	logger := NewLogger("TEST")
+	testLogSystem := &TestLogSystem{level: WarnLevel}
+	AddLogSystem(testLogSystem)
+	logger.Errorln("error")
+	logger.Warnln("warn")
+	logger.Infoln("info")
+	logger.Debugln("debug")
+	Flush()
+	output := testLogSystem.Output
+	fmt.Println(quote(output))
+	if output != "[TEST] error\n[TEST] warn\n" {
+		t.Error("Expected logger output '[TEST] error\\n[TEST] warn\\n', got ", quote(testLogSystem.Output))
+	}
 }
 
 func TestLoggerPrintf(t *testing.T) {
-  logger := NewLogger("TEST")
-  testLogSystem := &TestLogSystem{level: WarnLevel}
-  AddLogSystem(testLogSystem)
-  logger.Errorf("error to %v\n", *testLogSystem)
-  logger.Warnf("warn")
-  logger.Infof("info")
-  logger.Debugf("debug")
-  Flush()
-  output := testLogSystem.Output
-  fmt.Println(quote(output))
-  if output != "[TEST] error to { 2}\n[TEST] warn" {
-    t.Error("Expected logger output '[TEST] error to { 2}\\n[TEST] warn', got ", quote(testLogSystem.Output))
-  }
+	logger := NewLogger("TEST")
+	testLogSystem := &TestLogSystem{level: WarnLevel}
+	AddLogSystem(testLogSystem)
+	logger.Errorf("error to %v\n", *testLogSystem)
+	logger.Warnf("warn")
+	logger.Infof("info")
+	logger.Debugf("debug")
+	Flush()
+	output := testLogSystem.Output
+	fmt.Println(quote(output))
+	if output != "[TEST] error to { 2}\n[TEST] warn" {
+		t.Error("Expected logger output '[TEST] error to { 2}\\n[TEST] warn', got ", quote(testLogSystem.Output))
+	}
 }
 
 func TestMultipleLogSystems(t *testing.T) {
-  logger := NewLogger("TEST")
-  testLogSystem0 := &TestLogSystem{level: ErrorLevel}
-  testLogSystem1 := &TestLogSystem{level: WarnLevel}
-  AddLogSystem(testLogSystem0)
-  AddLogSystem(testLogSystem1)
-  logger.Errorln("error")
-  logger.Warnln("warn")
-  Flush()
-  output0 := testLogSystem0.Output
-  output1 := testLogSystem1.Output
-  if output0 != "[TEST] error\n" {
-    t.Error("Expected logger 0 output '[TEST] error\\n', got ", quote(testLogSystem0.Output))
-  }
-  if output1 != "[TEST] error\n[TEST] warn\n" {
-    t.Error("Expected logger 1 output '[TEST] error\\n[TEST] warn\\n', got ", quote(testLogSystem1.Output))
-  }
+	logger := NewLogger("TEST")
+	testLogSystem0 := &TestLogSystem{level: ErrorLevel}
+	testLogSystem1 := &TestLogSystem{level: WarnLevel}
+	AddLogSystem(testLogSystem0)
+	AddLogSystem(testLogSystem1)
+	logger.Errorln("error")
+	logger.Warnln("warn")
+	Flush()
+	output0 := testLogSystem0.Output
+	output1 := testLogSystem1.Output
+	if output0 != "[TEST] error\n" {
+		t.Error("Expected logger 0 output '[TEST] error\\n', got ", quote(testLogSystem0.Output))
+	}
+	if output1 != "[TEST] error\n[TEST] warn\n" {
+		t.Error("Expected logger 1 output '[TEST] error\\n[TEST] warn\\n', got ", quote(testLogSystem1.Output))
+	}
 }
 
 func TestFileLogSystem(t *testing.T) {
-  logger := NewLogger("TEST")
-  filename := "test.log"
-  file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
-  testLogSystem := NewStdLogSystem(file, 0, WarnLevel)
-  AddLogSystem(testLogSystem)
-  logger.Errorf("error to %s\n", filename)
-  logger.Warnln("warn")
-  Flush()
-  contents, _ :=  ioutil.ReadFile(filename)
-  output := string(contents)
-  fmt.Println(quote(output))
-  if output != "[TEST] error to test.log\n[TEST] warn\n" {
-    t.Error("Expected contents of file 'test.log': '[TEST] error to test.log\\n[TEST] warn\\n', got ", quote(output))
-  } else {
-    os.Remove(filename)
-  }
+	logger := NewLogger("TEST")
+	filename := "test.log"
+	file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+	testLogSystem := NewStdLogSystem(file, 0, WarnLevel)
+	AddLogSystem(testLogSystem)
+	logger.Errorf("error to %s\n", filename)
+	logger.Warnln("warn")
+	Flush()
+	contents, _ := ioutil.ReadFile(filename)
+	output := string(contents)
+	fmt.Println(quote(output))
+	if output != "[TEST] error to test.log\n[TEST] warn\n" {
+		t.Error("Expected contents of file 'test.log': '[TEST] error to test.log\\n[TEST] warn\\n', got ", quote(output))
+	} else {
+		os.Remove(filename)
+	}
 }
 
 func TestNoLogSystem(t *testing.T) {
-  logger := NewLogger("TEST")
-  logger.Warnln("warn")
-  Flush()
+	logger := NewLogger("TEST")
+	logger.Warnln("warn")
+	Flush()
 }
-
-
-
-
-
-

ethminer/miner.go

@@ -3,9 +3,9 @@ package ethminer
 import (
 	"bytes"
 	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethwire"
-	"github.com/ethereum/eth-go/ethlog"
 	"sort"
 )
 
@@ -57,18 +57,23 @@ func NewDefaultMiner(coinbase []byte, ethereum ethchain.EthManager) Miner {
 
 	return miner
 }
+
 func (miner *Miner) Start() {
 	// Prepare inital block
 	//miner.ethereum.StateManager().Prepare(miner.block.State(), miner.block.State())
 	go miner.listener()
+	logger.Infoln("Started")
 }
+
 func (miner *Miner) listener() {
 out:
 	for {
 		select {
 		case <-miner.quitChan:
+			logger.Infoln("Stopped")
 			break out
 		case chanMessage := <-miner.reactChan:
+
 			if block, ok := chanMessage.Resource.(*ethchain.Block); ok {
 				//logger.Infoln("Got new block via Reactor")
 				if bytes.Compare(miner.ethereum.BlockChain().CurrentBlock.Hash(), block.Hash()) == 0 {
@@ -123,8 +128,9 @@ out:
 }
 
 func (self *Miner) Stop() {
-	self.powQuitChan <- ethutil.React{}
+	logger.Infoln("Stopping...")
 	self.quitChan <- true
+	self.powQuitChan <- ethutil.React{}
 }
 
 func (self *Miner) mineNewBlock() {

ethpub/pub.go

@@ -5,8 +5,8 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"github.com/ethereum/eth-go/ethchain"
-	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethutil"
 	"math/big"
 	"strings"
 	"sync/atomic"

ethrpc/server.go

@@ -2,8 +2,8 @@ package ethrpc
 
 import (
 	"fmt"
-	"github.com/ethereum/eth-go/ethpub"
 	"github.com/ethereum/eth-go/ethlog"
+	"github.com/ethereum/eth-go/ethpub"
 	"net"
 	"net/rpc"
 	"net/rpc/jsonrpc"

ethutil/config.go

@@ -4,8 +4,8 @@ import (
 	"flag"
 	"fmt"
 	"github.com/rakyll/globalconf"
-	"runtime"
 	"os"
+	"runtime"
 )
 
 // Config struct
@@ -29,21 +29,21 @@ var Config *config
 // Initialize Config from Config File
 func ReadConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) *config {
 	if Config == nil {
-	 	// create ConfigFile if does not exist, otherwise globalconf panic when trying to persist flags
-    _, err := os.Stat(ConfigFile)
-    if err != nil && os.IsNotExist(err) {
+		// create ConfigFile if does not exist, otherwise globalconf panic when trying to persist flags
+		_, err := os.Stat(ConfigFile)
+		if err != nil && os.IsNotExist(err) {
 			fmt.Printf("config file '%s' doesn't exist, creating it\n", ConfigFile)
-      os.Create(ConfigFile)
-    }
-    g, err := globalconf.NewWithOptions(&globalconf.Options{
- 			Filename: ConfigFile,
- 			EnvPrefix: EnvPrefix,
+			os.Create(ConfigFile)
+		}
+		g, err := globalconf.NewWithOptions(&globalconf.Options{
+			Filename:  ConfigFile,
+			EnvPrefix: EnvPrefix,
 		})
 		if err != nil {
- 			fmt.Println(err)
-	  } else {
-	   g.ParseAll()
-	  }
+			fmt.Println(err)
+		} else {
+			g.ParseAll()
+		}
 		Config = &config{ExecPath: Datadir, Debug: true, Ver: "0.5.14", conf: g, Identifier: Identifier}
 		Config.SetClientString("Ethereum(G)")
 	}

ethutil/encoding_test.go

@@ -64,4 +64,4 @@ func TestCompactDecode(t *testing.T) {
 	if !CompareIntSlice(res, exp) {
 		t.Error("even terminated compact decode. Expected", exp, "got", res)
 	}
-}
+}
\ No newline at end of file

peer.go

@@ -5,9 +5,9 @@ import (
 	"container/list"
 	"fmt"
 	"github.com/ethereum/eth-go/ethchain"
+	"github.com/ethereum/eth-go/ethlog"
 	"github.com/ethereum/eth-go/ethutil"
 	"github.com/ethereum/eth-go/ethwire"
-	"github.com/ethereum/eth-go/ethlog"
 	"net"
 	"strconv"
 	"strings"