cmd/ethereum: improve command line interface

The ethereum command line interface is now structured using subcommands.
These separate the different tasks it can perform.

Almost all flag names are backwards compatible.

The key tasks have not been ported to subcommands since they will be
replaced by the new accounts infrastructure very soon.

2 files changed, 194 insertions, 9 deletions

diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
index 2bd34d792..3c3d3955d 100644
--- a/cmd/utils/cmd.go
+++ b/cmd/utils/cmd.go
@@ -27,6 +27,7 @@ import (
 	"os/signal"
 	"regexp"
 
+	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth"
@@ -108,13 +109,20 @@ func InitConfig(vmType int, ConfigFile string, Datadir string, EnvPrefix string)
 func exit(err error) {
 	status := 0
 	if err != nil {
-		clilogger.Errorln("Fatal: ", err)
+		fmt.Fprintln(os.Stderr, "Fatal: ", err)
 		status = 1
 	}
 	logger.Flush()
 	os.Exit(status)
 }
 
+// Fatalf formats a message to standard output and exits the program.
+func Fatalf(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, "Fatal: "+format+"\n", args...)
+	logger.Flush()
+	os.Exit(1)
+}
+
 func StartEthereum(ethereum *eth.Ethereum) {
 	clilogger.Infoln("Starting ", ethereum.Name())
 	if err := ethereum.Start(); err != nil {
@@ -127,7 +135,6 @@ func StartEthereum(ethereum *eth.Ethereum) {
 }
 
 func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
-
 	var err error
 	switch {
 	case GenAddr:
@@ -200,24 +207,24 @@ func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
 
 }
 
-func ImportChain(ethereum *eth.Ethereum, fn string) error {
-	clilogger.Infof("importing chain '%s'\n", fn)
+func ImportChain(chain *core.ChainManager, fn string) error {
+	fmt.Printf("importing chain '%s'\n", fn)
 	fh, err := os.OpenFile(fn, os.O_RDONLY, os.ModePerm)
 	if err != nil {
 		return err
 	}
 	defer fh.Close()
 
-	var chain types.Blocks
-	if err := rlp.Decode(fh, &chain); err != nil {
+	var blocks types.Blocks
+	if err := rlp.Decode(fh, &blocks); err != nil {
 		return err
 	}
 
-	ethereum.ChainManager().Reset()
-	if err := ethereum.ChainManager().InsertChain(chain); err != nil {
+	chain.Reset()
+	if err := chain.InsertChain(blocks); err != nil {
 		return err
 	}
-	clilogger.Infof("imported %d blocks\n", len(chain))
+	fmt.Printf("imported %d blocks\n", len(blocks))
 
 	return nil
 }
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
new file mode 100644
index 000000000..fb80ac708
--- /dev/null
+++ b/cmd/utils/flags.go
@@ -0,0 +1,178 @@
+package utils
+
+import (
+	"crypto/ecdsa"
+	"path"
+	"runtime"
+
+	"github.com/codegangsta/cli"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/p2p/nat"
+)
+
+// These are all the command line flags we support.
+// If you add to this list, please remember to include the
+// flag in the appropriate command definition.
+//
+// The flags are defined here so their names and help texts
+// are the same for all commands.
+
+var (
+	// General settings
+	VMTypeFlag = cli.IntFlag{
+		Name:  "vm",
+		Usage: "Virtual Machine type: 0 is standard VM, 1 is debug VM",
+	}
+	KeyRingFlag = cli.StringFlag{
+		Name:  "keyring",
+		Usage: "Name of keyring to be used",
+		Value: "",
+	}
+	KeyStoreFlag = cli.StringFlag{
+		Name:  "keystore",
+		Usage: `Where to store keyrings: "db" or "file"`,
+		Value: "db",
+	}
+	DataDirFlag = cli.StringFlag{
+		Name:  "datadir",
+		Usage: "Data directory to be used",
+		Value: ethutil.DefaultDataDir(),
+	}
+	MinerThreadsFlag = cli.IntFlag{
+		Name:  "minerthreads",
+		Usage: "Number of miner threads",
+		Value: runtime.NumCPU(),
+	}
+	MiningEnabledFlag = cli.BoolFlag{
+		Name:  "mine",
+		Usage: "Enable mining",
+	}
+
+	LogFileFlag = cli.StringFlag{
+		Name:  "logfile",
+		Usage: "Send log output to a file",
+	}
+	LogLevelFlag = cli.IntFlag{
+		Name:  "loglevel",
+		Usage: "0-5 (silent, error, warn, info, debug, debug detail)",
+		Value: int(logger.InfoLevel),
+	}
+	LogFormatFlag = cli.StringFlag{
+		Name:  "logformat",
+		Usage: `"std" or "raw"`,
+		Value: "std",
+	}
+
+	// RPC settings
+	RPCEnabledFlag = cli.BoolFlag{
+		Name:  "rpc",
+		Usage: "Whether RPC server is enabled",
+	}
+	RPCListenAddrFlag = cli.StringFlag{
+		Name:  "rpcaddr",
+		Usage: "Listening address for the JSON-RPC server",
+		Value: "127.0.0.1",
+	}
+	RPCPortFlag = cli.IntFlag{
+		Name:  "rpcport",
+		Usage: "Port on which the JSON-RPC server should listen",
+		Value: 8545,
+	}
+
+	// Network Settings
+	MaxPeersFlag = cli.IntFlag{
+		Name:  "maxpeers",
+		Usage: "Maximum number of network peers",
+		Value: 16,
+	}
+	ListenPortFlag = cli.IntFlag{
+		Name:  "port",
+		Usage: "Network listening port",
+		Value: 30303,
+	}
+	BootnodesFlag = cli.StringFlag{
+		Name:  "bootnodes",
+		Usage: "Space-separated enode URLs for discovery bootstrap",
+		Value: "",
+	}
+	NodeKeyFileFlag = cli.StringFlag{
+		Name:  "nodekey",
+		Usage: "P2P node key file",
+	}
+	NodeKeyHexFlag = cli.StringFlag{
+		Name:  "nodekeyhex",
+		Usage: "P2P node key as hex (for testing)",
+	}
+	NATFlag = cli.StringFlag{
+		Name:  "nat",
+		Usage: "Port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
+		Value: "any",
+	}
+)
+
+func GetNAT(ctx *cli.Context) nat.Interface {
+	natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
+	if err != nil {
+		Fatalf("Option %s: %v", NATFlag.Name, err)
+	}
+	return natif
+}
+
+func GetNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) {
+	hex, file := ctx.GlobalString(NodeKeyHexFlag.Name), ctx.GlobalString(NodeKeyFileFlag.Name)
+	var err error
+	switch {
+	case file != "" && hex != "":
+		Fatalf("Options %q and %q are mutually exclusive", NodeKeyFileFlag.Name, NodeKeyHexFlag.Name)
+	case file != "":
+		if key, err = crypto.LoadECDSA(file); err != nil {
+			Fatalf("Option %q: %v", NodeKeyFileFlag.Name, err)
+		}
+	case hex != "":
+		if key, err = crypto.HexToECDSA(hex); err != nil {
+			Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
+		}
+	}
+	return key
+}
+
+func GetEthereum(clientID, version string, ctx *cli.Context) *eth.Ethereum {
+	ethereum, err := eth.New(&eth.Config{
+		Name:         p2p.MakeName(clientID, version),
+		KeyStore:     ctx.GlobalString(KeyStoreFlag.Name),
+		DataDir:      ctx.GlobalString(DataDirFlag.Name),
+		LogFile:      ctx.GlobalString(LogFileFlag.Name),
+		LogLevel:     ctx.GlobalInt(LogLevelFlag.Name),
+		LogFormat:    ctx.GlobalString(LogFormatFlag.Name),
+		MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name),
+
+		MaxPeers:  ctx.GlobalInt(MaxPeersFlag.Name),
+		Port:      ctx.GlobalString(ListenPortFlag.Name),
+		NAT:       GetNAT(ctx),
+		NodeKey:   GetNodeKey(ctx),
+		KeyRing:   ctx.GlobalString(KeyRingFlag.Name),
+		Shh:       true,
+		Dial:      true,
+		BootNodes: ctx.GlobalString(BootnodesFlag.Name),
+	})
+	if err != nil {
+		exit(err)
+	}
+	return ethereum
+}
+
+func GetChain(ctx *cli.Context) (*core.ChainManager, ethutil.Database) {
+	dataDir := ctx.GlobalString(DataDirFlag.Name)
+	db, err := ethdb.NewLDBDatabase(path.Join(dataDir, "blockchain"))
+	if err != nil {
+		Fatalf("Could not open database: %v", err)
+	}
+	return core.NewChainManager(db, new(event.TypeMux)), db
+}