go fmt

2 files changed, 173 insertions, 179 deletions

diff --git a/ethlog/loggers.go b/ethlog/loggers.go
index be42c9fb7..9ebe59096 100644
--- a/ethlog/loggers.go
+++ b/ethlog/loggers.go
@@ -1,188 +1,188 @@
 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}
 }
-
diff --git a/ethlog/loggers_test.go b/ethlog/loggers_test.go
index c33082012..89f416681 100644
--- a/ethlog/loggers_test.go
+++ b/ethlog/loggers_test.go
@@ -1,115 +1,109 @@
 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()
 }
-
-
-
-
-
-