Merge branch 'poc-9' into develop

2 files changed, 208 insertions, 50 deletions

diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
index 723cfa887..a77c6ad4d 100644
--- a/cmd/utils/cmd.go
+++ b/cmd/utils/cmd.go
@@ -27,12 +27,12 @@ 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"
 	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/rlp"
 	rpchttp "github.com/ethereum/go-ethereum/rpc/http"
 	"github.com/ethereum/go-ethereum/state"
@@ -109,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 {
@@ -128,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:
@@ -161,7 +167,7 @@ func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, Secre
 
 func StartRpc(ethereum *eth.Ethereum, RpcListenAddress string, RpcPort int) {
 	var err error
-	ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum), RpcListenAddress, RpcPort)
+	ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum, nil), RpcListenAddress, RpcPort)
 	if err != nil {
 		clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
 	} else {
@@ -169,32 +175,6 @@ func StartRpc(ethereum *eth.Ethereum, RpcListenAddress string, RpcPort int) {
 	}
 }
 
-var gminer *miner.Miner
-
-func GetMiner() *miner.Miner {
-	return gminer
-}
-
-func StartMining(ethereum *eth.Ethereum) bool {
-	if !ethereum.Mining {
-		ethereum.Mining = true
-		addr := ethereum.KeyManager().Address()
-
-		go func() {
-			clilogger.Infoln("Start mining")
-			if gminer == nil {
-				gminer = miner.New(addr, ethereum, 4)
-			}
-			gminer.Start()
-		}()
-		RegisterInterrupt(func(os.Signal) {
-			StopMining(ethereum)
-		})
-		return true
-	}
-	return false
-}
-
 func FormatTransactionData(data string) []byte {
 	d := ethutil.StringToByteFunc(data, func(s string) (ret []byte) {
 		slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
@@ -208,18 +188,6 @@ func FormatTransactionData(data string) []byte {
 	return d
 }
 
-func StopMining(ethereum *eth.Ethereum) bool {
-	if ethereum.Mining && gminer != nil {
-		gminer.Stop()
-		clilogger.Infoln("Stopped mining")
-		ethereum.Mining = false
-
-		return true
-	}
-
-	return false
-}
-
 // Replay block
 func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
 	block := ethereum.ChainManager().GetBlock(hash)
@@ -229,7 +197,7 @@ func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
 
 	parent := ethereum.ChainManager().GetBlock(block.ParentHash())
 
-	statedb := state.New(parent.Root(), ethereum.Db())
+	statedb := state.New(parent.Root(), ethereum.StateDb())
 	_, err := ethereum.BlockProcessor().TransitionState(statedb, parent, block, true)
 	if err != nil {
 		return err
@@ -239,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..88ff3558d
--- /dev/null
+++ b/cmd/utils/flags.go
@@ -0,0 +1,190 @@
+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",
+		}
+	*/
+	VMDebugFlag = cli.BoolFlag{
+		Name:  "vmdebug",
+		Usage: "Virtual Machine debug output",
+	}
+	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),
+		VmDebug:      ctx.GlobalBool(VMDebugFlag.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, ethutil.Database) {
+	dataDir := ctx.GlobalString(DataDirFlag.Name)
+	blockDb, err := ethdb.NewLDBDatabase(path.Join(dataDir, "blockchain"))
+	if err != nil {
+		Fatalf("Could not open database: %v", err)
+	}
+
+	stateDb, err := ethdb.NewLDBDatabase(path.Join(dataDir, "state"))
+	if err != nil {
+		Fatalf("Could not open database: %v", err)
+	}
+	return core.NewChainManager(blockDb, stateDb, new(event.TypeMux)), blockDb, stateDb
+}