refactor cli and gui wrapper code. Details:

- all cli functions shared between ethereum and ethereal abstracted to utils/ cmd.go (should be ethcommon or shared or sth)
- simplify main() now readable stepwise
- rename main wrapper files to main.go
- rename commmand line args definition file from config.go to flags.go
- rename Do -> Start to parallel option names
- register interrupt for rpc server stop
- fix interrupt stopping js repl and ethereum
- register interrupt for mining stop
- custom config file option from command line
- debug option from command line
- loglevel option from command line
- changed ethutil.Config API
- default datadir and default config file set together with other flag defaults in wrappers
- default assetpath set together with other command line flags defaults in gui wrapper (not in ethutil.Config or ui/ui_lib)
- options precedence: default < config file < environment variables < command line

ethereal/config.go

@@ -1,43 +0,0 @@
-package main
-
-import (
-	"flag"
-)
-
-var Identifier string
-
-//var StartMining bool
-var StartRpc bool
-var RpcPort int
-var UseUPnP bool
-var OutboundPort string
-var ShowGenesis bool
-var AddPeer string
-var MaxPeer int
-var GenAddr bool
-var UseSeed bool
-var ImportKey string
-var ExportKey bool
-var AssetPath string
-
-var Datadir string
-
-func Init() {
-	flag.StringVar(&Identifier, "id", "", "Custom client identifier")
-	flag.StringVar(&OutboundPort, "port", "30303", "listening port")
-	flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
-	flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers")
-	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
-	flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
-	flag.StringVar(&AssetPath, "asset_path", "", "absolute path to GUI assets directory")
-
-	flag.BoolVar(&ShowGenesis, "genesis", false, "prints genesis header and exits")
-	flag.BoolVar(&UseSeed, "seed", true, "seed peers")
-	flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
-	flag.BoolVar(&ExportKey, "export", false, "export private key")
-	flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)")
-
-	flag.StringVar(&Datadir, "datadir", ".ethereal", "specifies the datadir to use. Takes precedence over config file.")
-
-	flag.Parse()
-}

ethereal/ethereum.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/ethereum/go-ethereum/ethereal/ui"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/go-qml/qml"
-	"github.com/rakyll/globalconf"
-	"log"
-	"os"
-	"os/signal"
-	"path"
-	"runtime"
-)
-
-const Debug = true
-
-// Register interrupt handlers so we can stop the ethereum
-func RegisterInterupts(s *eth.Ethereum) {
-	// Buffered chan of one is enough
-	c := make(chan os.Signal, 1)
-	// Notify about interrupts for now
-	signal.Notify(c, os.Interrupt)
-	go func() {
-		for sig := range c {
-			fmt.Printf("Shutting down (%v) ... \n", sig)
-
-			s.Stop()
-		}
-	}()
-}
-
-func main() {
-	Init()
-
-	qml.Init(nil)
-
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	g, err := globalconf.NewWithOptions(&globalconf.Options{
-		Filename: path.Join(ethutil.ApplicationFolder(Datadir), "conf.ini"),
-	})
-	if err != nil {
-		fmt.Println(err)
-	} else {
-		g.ParseAll()
-	}
-	ethutil.ReadConfig(Datadir, ethutil.LogFile|ethutil.LogStd, g, Identifier)
-
-	// Instantiated a eth stack
-	ethereum, err := eth.New(eth.CapDefault, UseUPnP)
-	if err != nil {
-		log.Println("eth start err:", err)
-		return
-	}
-	ethereum.Port = OutboundPort
-
-	if GenAddr {
-		fmt.Println("This action overwrites your old private key. Are you sure? (y/n)")
-
-		var r string
-		fmt.Scanln(&r)
-		for ; ; fmt.Scanln(&r) {
-			if r == "n" || r == "y" {
-				break
-			} else {
-				fmt.Printf("Yes or no?", r)
-			}
-		}
-
-		if r == "y" {
-			utils.CreateKeyPair(true)
-		}
-		os.Exit(0)
-	} else {
-		if len(ImportKey) > 0 {
-			fmt.Println("This action overwrites your old private key. Are you sure? (y/n)")
-			var r string
-			fmt.Scanln(&r)
-			for ; ; fmt.Scanln(&r) {
-				if r == "n" || r == "y" {
-					break
-				} else {
-					fmt.Printf("Yes or no?", r)
-				}
-			}
-
-			if r == "y" {
-				utils.ImportPrivateKey(ImportKey)
-				os.Exit(0)
-			}
-		}
-	}
-
-	if ExportKey {
-		keyPair := ethutil.GetKeyRing().Get(0)
-		fmt.Printf(`
-Generating new address and keypair.
-Please keep your keys somewhere save.
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-save these words so you can restore your account later: %s
-`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey)
-
-		os.Exit(0)
-	}
-
-	if ShowGenesis {
-		fmt.Println(ethereum.BlockChain().Genesis())
-		os.Exit(0)
-	}
-
-	/*
-		if StartMining {
-			utils.DoMining(ethereum)
-		}
-	*/
-
-	if StartRpc {
-		utils.DoRpc(ethereum, RpcPort)
-	}
-
-	log.Printf("Starting Ethereum GUI v%s\n", ethutil.Config.Ver)
-
-	// Set the max peers
-	ethereum.MaxPeers = MaxPeer
-
-	gui := ethui.New(ethereum)
-
-	ethereum.Start(UseSeed)
-
-	gui.Start(AssetPath)
-
-	// Wait for shutdown
-	ethereum.WaitForShutdown()
-}

ethereal/flags.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"flag"
+)
+
+var Identifier string
+var StartRpc bool
+var RpcPort int
+var UseUPnP bool
+var OutboundPort string
+var ShowGenesis bool
+var AddPeer string
+var MaxPeer int
+var GenAddr bool
+var UseSeed bool
+var ImportKey string
+var ExportKey bool
+var NonInteractive bool
+var Datadir string
+var LogFile string
+var ConfigFile string
+var DebugFile string
+var LogLevel int
+
+// flags specific to gui client
+var AssetPath string
+
+func defaultAssetPath() string {
+	var assetPath string
+	// If the current working directory is the go-ethereum dir
+	// assume a debug build and use the source directory as
+	// asset directory.
+	pwd, _ := os.Getwd()
+	if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal") {
+		assetPath = path.Join(pwd, "assets")
+	} else {
+		switch runtime.GOOS {
+		case "darwin":
+			// Get Binary Directory
+			exedir, _ := osext.ExecutableFolder()
+			assetPath = filepath.Join(exedir, "../Resources")
+		case "linux":
+			assetPath = "/usr/share/ethereal"
+		case "window":
+			fallthrough
+		default:
+			assetPath = "."
+		}
+	}
+	return assetPath
+}
+
+func defaultDataDir() string {
+  usr, _ := user.Current()
+  return path.Join(usr.HomeDir, ".ethereum")
+}
+
+var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
+
+func Init() {
+	flag.StringVar(&Identifier, "id", "", "Custom client identifier")
+	flag.StringVar(&OutboundPort, "port", "30303", "listening port")
+	flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
+	flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers")
+	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
+	flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
+	flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
+	flag.BoolVar(&UseSeed, "seed", true, "seed peers")
+	flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
+	flag.BoolVar(&ExportKey, "export", false, "export private key")
+	flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
+	flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)")
+	flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
+	flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
+	flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
+	flag.IntVar(&LogLevel, "loglevel", int(ethlog.InfoLevel), "loglevel: 0-4: silent,error,warn,info,debug)")
+	flag.StringVar(&AssetPath, "asset_path", defaultAssetPath, "absolute path to GUI assets directory")
+
+	flag.Parse()
+}

ethereal/main.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"github.com/ethereum/go-ethereum/ethereal/ui"
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/go-qml/qml"
+	"runtime"
+)
+
+const Debug = true
+
+func main() {
+	qml.Init(nil)
+
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	// precedence: code-internal flag default < config file < environment variables < command line
+	Init() // parsing command line
+	utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH")
+
+	utils.InitDataDir(Datadir)
+
+	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
+
+	ethereum := utils.NewEthereum(UseUPnP, OutboundPort, MaxPeer)
+
+	// create, import, export keys
+  utils.KeyTasks(GenAddr, ImportKey, ExportKey, NonInteractive)
+
+  if ShowGenesis {
+    utils.ShowGenesis(ethereum)
+  }
+
+	if StartRpc {
+		utils.StartRpc(ethereum, RpcPort)
+	}
+
+	utils.StartEthereum(ethereum, UseSeed)
+
+	gui := ethui.New(ethereum, logLevel)
+	gui.Start(AssetPath)
+}

ethereal/ui/ui_lib.go

@@ -29,9 +29,6 @@ type UiLib struct {
 }
 
 func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
-	if assetPath == "" {
-		assetPath = DefaultAssetPath()
-	}
 	return &UiLib{engine: engine, eth: eth, assetPath: assetPath}
 }
 
@@ -88,6 +85,7 @@ func (ui *UiLib) ConnectToPeer(addr string) {
 func (ui *UiLib) AssetPath(p string) string {
 	return path.Join(ui.assetPath, p)
 }
+
 func (self *UiLib) StartDbWithContractAndData(contractHash, data string) {
 	dbWindow := NewDebuggerWindow(self)
 	object := self.eth.StateManager().CurrentState().GetStateObject(ethutil.FromHex(contractHash))
@@ -111,29 +109,3 @@ func (self *UiLib) StartDebugger() {
 
 	dbWindow.Show()
 }
-
-func DefaultAssetPath() string {
-	var base string
-	// If the current working directory is the go-ethereum dir
-	// assume a debug build and use the source directory as
-	// asset directory.
-	pwd, _ := os.Getwd()
-	if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal") {
-		base = path.Join(pwd, "assets")
-	} else {
-		switch runtime.GOOS {
-		case "darwin":
-			// Get Binary Directory
-			exedir, _ := osext.ExecutableFolder()
-			base = filepath.Join(exedir, "../Resources")
-		case "linux":
-			base = "/usr/share/ethereal"
-		case "window":
-			fallthrough
-		default:
-			base = "."
-		}
-	}
-
-	return base
-}

ethereum/cmd.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+  "github.com/ethereum/eth-go"
+  "github.com/ethereum/go-ethereum/utils"
+  "os"
+  "io/ioutil"
+)
+
+func InitJsConsole(ethereum *eth.Ethereum) {
+  repl := NewJSRepl(ethereum)
+  go repl.Start()
+  utils.RegisterInterrupt(func(os.Signal) {
+    repl.Stop()
+    ethereum.Stop()
+  })
+}
+
+func ExecJsFile (ethereum *eth.Ethereum, InputFile string) {
+  file, err := os.Open(InputFile)
+  if err != nil {
+    logger.Fatalln(err)
+  }
+  content, err := ioutil.ReadAll(file)
+  if err != nil {
+    logger.Fatalln(err)
+  }
+  re := NewJSRE(ethereum)
+  utils.RegisterInterrupt(func(os.Signal) {
+    re.Stop()
+  })
+  re.Run(string(content))
+}

ethereum/ethereum.go

@@ -1,193 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/ethereum/eth-go"
-	"github.com/ethereum/eth-go/ethutil"
-	"github.com/ethereum/go-ethereum/utils"
-	"github.com/rakyll/globalconf"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/signal"
-	"path"
-	"runtime"
-	"strings"
-)
-
-const Debug = true
-
-func RegisterInterrupt(cb func(os.Signal)) {
-	go func() {
-		// Buffered chan of one is enough
-		c := make(chan os.Signal, 1)
-		// Notify about interrupts for now
-		signal.Notify(c, os.Interrupt)
-
-		for sig := range c {
-			cb(sig)
-		}
-	}()
-}
-
-func confirm(message string) bool {
-	fmt.Println(message, "Are you sure? (y/n)")
-	var r string
-	fmt.Scanln(&r)
-	for ; ; fmt.Scanln(&r) {
-		if r == "n" || r == "y" {
-			break
-		} else {
-			fmt.Printf("Yes or no?", r)
-		}
-	}
-	return r == "y"
-}
-
-func main() {
-	Init()
-
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	// set logger
-	var logSys *log.Logger
-	flags := log.LstdFlags
-
-	var lt ethutil.LoggerType
-	if StartJsConsole || len(InputFile) > 0 {
-		lt = ethutil.LogFile
-	} else {
-		lt = ethutil.LogFile | ethutil.LogStd
-	}
-
-	g, err := globalconf.NewWithOptions(&globalconf.Options{
-		Filename: path.Join(ethutil.ApplicationFolder(Datadir), "conf.ini"),
-	})
-	if err != nil {
-		fmt.Println(err)
-	} else {
-		g.ParseAll()
-	}
-	ethutil.ReadConfig(Datadir, lt, g, Identifier)
-
-	logger := ethutil.Config.Log
-
-	if LogFile != "" {
-		logfile, err := os.OpenFile(LogFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
-		if err != nil {
-			panic(fmt.Sprintf("error opening log file '%s': %v", LogFile, err))
-		}
-		defer logfile.Close()
-		log.SetOutput(logfile)
-		logSys = log.New(logfile, "", flags)
-		logger.AddLogSystem(logSys)
-	} else {
-		logSys = log.New(os.Stdout, "", flags)
-	}
-
-	// Instantiated a eth stack
-	ethereum, err := eth.New(eth.CapDefault, UseUPnP)
-	if err != nil {
-		log.Println("eth start err:", err)
-		return
-	}
-	ethereum.Port = OutboundPort
-
-	// bookkeeping tasks
-	switch {
-	case GenAddr:
-		if NonInteractive || confirm("This action overwrites your old private key.") {
-			utils.CreateKeyPair(true)
-		}
-		os.Exit(0)
-	case len(ImportKey) > 0:
-		if NonInteractive || confirm("This action overwrites your old private key.") {
-			mnemonic := strings.Split(ImportKey, " ")
-			if len(mnemonic) == 24 {
-				logSys.Println("Got mnemonic key, importing.")
-				key := ethutil.MnemonicDecode(mnemonic)
-				utils.ImportPrivateKey(key)
-			} else if len(mnemonic) == 1 {
-				logSys.Println("Got hex key, importing.")
-				utils.ImportPrivateKey(ImportKey)
-			} else {
-				logSys.Println("Did not recognise format, exiting.")
-			}
-		}
-		os.Exit(0)
-	case ExportKey:
-		keyPair := ethutil.GetKeyRing().Get(0)
-		fmt.Printf(`
-Generating new address and keypair.
-Please keep your keys somewhere save.
-
-++++++++++++++++ KeyRing +++++++++++++++++++
-addr: %x
-prvk: %x
-pubk: %x
-++++++++++++++++++++++++++++++++++++++++++++
-save these words so you can restore your account later: %s
-`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey)
-
-		os.Exit(0)
-	case ShowGenesis:
-		logSys.Println(ethereum.BlockChain().Genesis())
-		os.Exit(0)
-	default:
-		// Creates a keypair if non exists
-		utils.CreateKeyPair(false)
-	}
-
-	// client
-	logger.Infoln(fmt.Sprintf("Starting Ethereum v%s", ethutil.Config.Ver))
-
-	// Set the max peers
-	ethereum.MaxPeers = MaxPeer
-
-	// Set Mining status
-	ethereum.Mining = StartMining
-
-	if StartMining {
-		utils.DoMining(ethereum)
-	}
-
-	if StartJsConsole {
-		repl := NewJSRepl(ethereum)
-
-		go repl.Start()
-
-		RegisterInterrupt(func(os.Signal) {
-			repl.Stop()
-		})
-	} else if len(InputFile) > 0 {
-		file, err := os.Open(InputFile)
-		if err != nil {
-			ethutil.Config.Log.Fatal(err)
-		}
-
-		content, err := ioutil.ReadAll(file)
-		if err != nil {
-			ethutil.Config.Log.Fatal(err)
-		}
-
-		re := NewJSRE(ethereum)
-		RegisterInterrupt(func(os.Signal) {
-			re.Stop()
-		})
-		re.Run(string(content))
-	}
-
-	if StartRpc {
-		utils.DoRpc(ethereum, RpcPort)
-	}
-
-	RegisterInterrupt(func(sig os.Signal) {
-		fmt.Printf("Shutting down (%v) ... \n", sig)
-		ethereum.Stop()
-	})
-
-	ethereum.Start(UseSeed)
-
-	// Wait for shutdown
-	ethereum.WaitForShutdown()
-}

ethereum/flags.go

@@ -4,10 +4,12 @@ import (
 	"flag"
 	"fmt"
 	"os"
+  "os/user"
+  "path"
+  "github.com/ethereum/eth-go/ethlog"
 )
 
 var Identifier string
-var StartMining bool
 var StartRpc bool
 var RpcPort int
 var UseUPnP bool
@@ -19,16 +21,28 @@ var GenAddr bool
 var UseSeed bool
 var ImportKey string
 var ExportKey bool
-var LogFile string
 var NonInteractive bool
+var Datadir string
+var LogFile string
+var ConfigFile string
+var DebugFile string
+var LogLevel int
+
+// flags specific to cli client
+var StartMining bool
 var StartJsConsole bool
 var InputFile string
 
-var Datadir string
+func defaultDataDir() string {
+  usr, _ := user.Current()
+  return path.Join(usr.HomeDir, ".ethereum")
+}
+
+var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
 
 func Init() {
 	flag.Usage = func() {
-		fmt.Fprintf(os.Stderr, "%s [options] [filename]:\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line", os.Args[0])
 		flag.PrintDefaults()
 	}
 
@@ -38,17 +52,19 @@ func Init() {
 	flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers")
 	flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
 	flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
-	flag.BoolVar(&StartJsConsole, "js", false, "exp")
-
-	flag.BoolVar(&StartMining, "mine", false, "start dagger mining")
 	flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
 	flag.BoolVar(&UseSeed, "seed", true, "seed peers")
 	flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
 	flag.BoolVar(&ExportKey, "export", false, "export private key")
 	flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
 	flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)")
+	flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
+	flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
+	flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
+	flag.IntVar(&LogLevel, "loglevel", int(ethlog.InfoLevel), "loglevel: 0-4: silent,error,warn,info,debug)")
 
-	flag.StringVar(&Datadir, "datadir", ".ethereum", "specifies the datadir to use. Takes precedence over config file.")
+	flag.BoolVar(&StartMining, "mine", false, "start dagger mining")
+	flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console")
 
 	flag.Parse()
 

ethereum/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"github.com/ethereum/go-ethereum/utils"
+	"github.com/ethereum/eth-go/ethlog"
+	"runtime"
+)
+
+var logger = ethlog.NewLogger("CLI")
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	// precedence: code-internal flag default < config file < environment variables < command line
+	Init() // parsing command line
+	utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH")
+
+	utils.InitDataDir(Datadir)
+
+	utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
+
+	ethereum := utils.NewEthereum(UseUPnP, OutboundPort, MaxPeer)
+
+	// create, import, export keys
+  utils.KeyTasks(GenAddr, ImportKey, ExportKey, NonInteractive)
+
+  if ShowGenesis {
+    utils.ShowGenesis(ethereum)
+  }
+
+	if StartMining {
+		utils.StartMining(ethereum)
+	}
+
+	// better reworked as cases
+	if StartJsConsole {
+		InitJsConsole(ethereum)
+	} else if len(InputFile) > 0 {
+		ExecJsFile(ethereum, InputFile)
+	}
+
+	if StartRpc {
+		utils.StartRpc(ethereum, RpcPort)
+	}
+
+	utils.StartEthereum(ethereum, UseSeed)
+}

utils/cmd.go

@@ -6,69 +6,219 @@ import (
   "github.com/ethereum/eth-go/ethpub"
   "github.com/ethereum/eth-go/ethrpc"
   "github.com/ethereum/eth-go/ethutil"
+  "github.com/ethereum/eth-go/ethlog"
+  "log"
+  "io"
+  "path"
+  "os"
+  "os/signal"
+  "fmt"
   "time"
+  "strings"
 )
 
-func DoRpc(ethereum *eth.Ethereum, RpcPort int) {
+var logger = ethlog.NewLogger("CLI")
+
+// Register interrupt handlers
+func RegisterInterrupt(cb func(os.Signal)) {
+  go func() {
+    // Buffered chan of one is enough
+    c := make(chan os.Signal, 1)
+    // Notify about interrupts for now
+    signal.Notify(c, os.Interrupt)
+    for sig := range c {
+      cb(sig)
+    }
+  }()
+}
+
+func AbsolutePath(Datadir string, filename string) string {
+  if path.IsAbs(filename) {
+    return filename
+  }
+  return path.Join(Datadir, filename)
+}
+
+func openLogFile (Datadir string, filename string) *os.File {
+  path := AbsolutePath(Datadir, filename)
+  file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+  if err != nil {
+    panic(fmt.Sprintf("error opening log file '%s': %v", filename, err))
+  }
+  return file
+}
+
+func confirm (message string) bool {
+  fmt.Println(message, "Are you sure? (y/n)")
+  var r string
+  fmt.Scanln(&r)
+  for ; ; fmt.Scanln(&r) {
+    if r == "n" || r == "y" {
+      break
+    } else {
+      fmt.Printf("Yes or no?", r)
+    }
+  }
+  return r == "y"
+}
+
+func InitDataDir(Datadir string) {
+  _, err := os.Stat(Datadir)
+  if err != nil {
+    if os.IsNotExist(err) {
+      fmt.Printf("Debug logging directory '%s' doesn't exist, creating it\n", Datadir)
+      os.Mkdir(Datadir, 0777)
+    }
+  }
+}
+
+func InitLogging (Datadir string, LogFile string, LogLevel int, DebugFile string) {
+  var writer io.Writer
+  if LogFile == "" {
+    writer = os.Stdout
+  } else {
+    writer = openLogFile(Datadir, LogFile)
+  }
+  ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.LogLevel(LogLevel)))
+  if DebugFile != "" {
+    writer = openLogFile(Datadir, DebugFile)
+    ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.DebugLevel))
+  }
+}
+
+func InitConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) {
+  ethutil.ReadConfig(ConfigFile, Datadir, Identifier, EnvPrefix)
+  ethutil.Config.Set("rpcport", "700")
+}
+
+func exit(status int) {
+  ethlog.Flush()
+  os.Exit(status)
+}
+
+func NewEthereum(UseUPnP bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
+  ethereum, err := eth.New(eth.CapDefault, UseUPnP)
+  if err != nil {
+    logger.Fatalln("eth start err:", err)
+  }
+  ethereum.Port = OutboundPort
+  ethereum.MaxPeers = MaxPeer
+  return ethereum
+}
+
+func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
+  logger.Infof("Starting Ethereum v%s", ethutil.Config.Ver)
+  ethereum.Start(UseSeed)
+  // Wait for shutdown
+  ethereum.WaitForShutdown()
+  RegisterInterrupt(func(sig os.Signal) {
+    logger.Errorf("Shutting down (%v) ... \n", sig)
+    ethereum.Stop()
+    ethlog.Flush()
+  })
+}
+
+func ShowGenesis(ethereum *eth.Ethereum) {
+  logger.Infoln(ethereum.BlockChain().Genesis())
+  exit(0)
+}
+
+func KeyTasks(GenAddr bool, ImportKey string, ExportKey bool, NonInteractive bool) {
+  switch {
+  case GenAddr:
+    if NonInteractive || confirm("This action overwrites your old private key.") {
+      CreateKeyPair(true)
+    }
+    exit(0)
+  case len(ImportKey) > 0:
+    if NonInteractive || confirm("This action overwrites your old private key.") {
+      // import should be from file
+      mnemonic := strings.Split(ImportKey, " ")
+      if len(mnemonic) == 24 {
+        logger.Infoln("Got mnemonic key, importing.")
+        key := ethutil.MnemonicDecode(mnemonic)
+        ImportPrivateKey(key)
+      } else if len(mnemonic) == 1 {
+        logger.Infoln("Got hex key, importing.")
+        ImportPrivateKey(ImportKey)
+      } else {
+        logger.Errorln("Did not recognise format, exiting.")
+      }
+    }
+    exit(0)
+  case ExportKey: // this should be exporting to a filename
+    keyPair := ethutil.GetKeyRing().Get(0)
+    fmt.Printf(`
+Generating new address and keypair.
+Please keep your keys somewhere save.
+
+++++++++++++++++ KeyRing +++++++++++++++++++
+addr: %x
+prvk: %x
+pubk: %x
+++++++++++++++++++++++++++++++++++++++++++++
+save these words so you can restore your account later: %s
+`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey)
+
+    exit(0)
+  default:
+    // Creates a keypair if none exists
+    CreateKeyPair(false)
+  }
+}
+
+func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
   var err error
   ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort)
   if err != nil {
-		ethutil.Config.Log.Infoln("Could not start RPC interface:", err)
+    logger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
   } else {
     go ethereum.RpcServer.Start()
+    RegisterInterrupt(func(os.Signal) {
+      ethereum.RpcServer.Stop()
+    })
   }
 }
 
 var miner ethminer.Miner
 
-func DoMining(ethereum *eth.Ethereum) {
+func StartMining(ethereum *eth.Ethereum) bool {
-	// Set Mining status
+  if !ethereum.Mining {
     ethereum.Mining = true
 
     if ethutil.GetKeyRing().Len() == 0 {
-		ethutil.Config.Log.Infoln("No address found, can't start mining")
+      logger.Errorln("No address found, can't start mining")
-		return
+      ethereum.Mining = false
+      return true //????
     }
     keyPair := ethutil.GetKeyRing().Get(0)
     addr := keyPair.Address()
 
     go func() {
       miner = ethminer.NewDefaultMiner(addr, ethereum)
-
       // Give it some time to connect with peers
       time.Sleep(3 * time.Second)
-
       for ethereum.IsUpToDate() == false {
         time.Sleep(5 * time.Second)
       }
-
+      logger.Infoln("Miner started")
-		ethutil.Config.Log.Infoln("Miner started")
-
       miner := ethminer.NewDefaultMiner(addr, ethereum)
       miner.Start()
     }()
+    RegisterInterrupt(func(os.Signal) {
+      StopMining(ethereum)
+    })
+    return true
+  }
+  return false
 }
 
 func StopMining(ethereum *eth.Ethereum) bool {
   if ethereum.Mining {
     miner.Stop()
-
+    logger.Infoln("Miner stopped")
-		ethutil.Config.Log.Infoln("Miner stopped")
-
     ethereum.Mining = false
-
     return true
   }
-
-	return false
-}
-
-func StartMining(ethereum *eth.Ethereum) bool {
-	if !ethereum.Mining {
-		DoMining(ethereum)
-
-		return true
-	}
-
   return false
 }