Dev/ezdev

cmd/geth/cmd.go

@@ -31,6 +31,8 @@ import (
 	"syscall"
 	"time"
 
+	"math"
+
 	"github.com/ethereumproject/ethash"
 	"github.com/ethereumproject/go-ethereum/common"
 	"github.com/ethereumproject/go-ethereum/core"
@@ -44,7 +46,6 @@ import (
 	"github.com/ethereumproject/go-ethereum/pow"
 	"github.com/ethereumproject/go-ethereum/rlp"
 	"gopkg.in/urfave/cli.v1"
-	"math"
 )
 
 const (
@@ -637,7 +638,7 @@ func rollback(ctx *cli.Context) error {
 func dumpChainConfig(ctx *cli.Context) error {
 
 	chainIdentity := mustMakeChainIdentity(ctx)
-	if !(core.ChainIdentitiesMain[chainIdentity] || core.ChainIdentitiesMorden[chainIdentity]) {
+	if !(core.ChainIdentitiesMain[chainIdentity] || core.ChainIdentitiesMorden[chainIdentity] || chainIdentity == "ezdev") {
 		glog.Fatal("Dump config should only be used with default chain configurations (mainnet or morden).")
 	}
 
@@ -696,6 +697,10 @@ func dumpChainConfig(ctx *cli.Context) error {
 		Bootstrap:   nodes,
 	}
 
+	if ctx.GlobalBool(EZDevModeFlag.Name) {
+		currentConfig = core.DefaultConfigEZDev
+	}
+
 	if writeError := currentConfig.WriteToJSONFile(chainConfigFilePath); writeError != nil {
 		glog.Fatalf("An error occurred while writing chain configuration: %v", writeError)
 		return writeError

cmd/geth/ezdev.go

@@ -0,0 +1,113 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/ethereumproject/go-ethereum/core"
+	"github.com/ethereumproject/go-ethereum/logger"
+	"github.com/ethereumproject/go-ethereum/logger/glog"
+	"gopkg.in/urfave/cli.v1"
+)
+
+func mustSetCTXDefault(ctx *cli.Context, name, val string) {
+	if err := ctx.GlobalSet(aliasableName(name, ctx), val); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func setEZDevFlags(ctx *cli.Context) {
+	mustSetCTXDefault(ctx, NoDiscoverFlag.Name, "true")
+	mustSetCTXDefault(ctx, LightKDFFlag.Name, "true")
+	mustSetCTXDefault(ctx, MiningEnabledFlag.Name, "true")
+}
+
+func setupEZDev(ctx *cli.Context, config *core.SufficientChainConfig) error {
+	// set flag config defaults
+	// copy dev.json, dev_genesis.json, dev_genesis_allow.csv to datadir/ezdev/{ chain, dev_genesis, dev_genesis_alloc }.json/csv,
+	// init 10 accounts with password 'foo'
+	// add these accounts to genesis alloc csv
+
+	config.Include = []string{"dev_genesis.json"}
+
+	cg := config.Genesis
+
+	// Set original genesis to nil so no conflict between GenesisAlloc field and present Genesis obj.
+	config.Genesis = nil
+	cg.AllocFile = "dev_genesis_alloc.csv"
+
+	// because this cli ctx is weird and accounts seem slower to generate if this isn't here
+	setEZDevFlags(ctx)
+
+	// cc.Genesis = cg
+	// make some accounts
+	accman := MakeAccountManager(ctx)
+	data := []byte{}
+	bal := "10000000000000000000000000000000"
+	if len(accman.Accounts()) == 0 {
+		glog.D(logger.Warn).Infoln("No existing EZDEV accounts found, creating 10")
+		password := ""
+		// accounts := []accounts.Account{}
+		for i := 0; i < 10; i++ {
+			acc, err := accman.NewAccount(password)
+			if err != nil {
+				return err
+			}
+			// accounts = append(accounts, acc)
+			// a := acc.Address.Hex()
+			a := strings.Replace(acc.Address.Hex(), "0x", "", -1)
+			d := fmt.Sprintf(`"%s","%v"
+`, a, bal)
+			glog.D(logger.Warn).Infoln(acc.Address.Hex(), acc.File)
+			// b, ok := new(big.Int).SetString(bal, 10)
+			// if !ok {
+			// 	panic("not ok set string", b, bal)
+			// }
+			data = append(data, []byte(d)...)
+		}
+	} else {
+		glog.D(logger.Warn).Infoln("Found existing keyfiles, using: ")
+		for _, acc := range accman.Accounts() {
+			d := fmt.Sprintf("%s,%v\n", acc.Address.Hex(), bal)
+			glog.D(logger.Warn).Infoln(acc.Address.Hex(), acc.File)
+			data = append(data, []byte(d)...)
+		}
+	}
+
+	// marshal and write config json IFF it doesn't already exist
+	if _, err := os.Stat(filepath.Join(MustMakeChainDataDir(ctx), "chain.json")); err != nil && os.IsNotExist(err) {
+
+		if err := config.WriteToJSONFile(filepath.Join(MustMakeChainDataDir(ctx), "chain.json")); err != nil {
+			return err
+		}
+	}
+
+	// marshal and write dev_genesis.json
+	genC, err := json.MarshalIndent(struct {
+		Genesis *core.GenesisDump `json:"genesis"`
+	}{cg}, "", "    ")
+	if err != nil {
+		return fmt.Errorf("Could not marshal json from chain config: %v", err)
+	}
+	if err := ioutil.WriteFile(filepath.Join(MustMakeChainDataDir(ctx), "dev_genesis.json"), genC, 0644); err != nil {
+		return err
+	}
+
+	// write alloc file, ALWAYS, because these never change and it's just extra logic, even though it would seem more right to care if the file already exists or not
+	ioutil.WriteFile(filepath.Join(MustMakeChainDataDir(ctx), "dev_genesis_alloc.csv"), data, os.ModePerm)
+
+	// again.. hacky. maybe unnecessary.
+	cc, err := core.ReadExternalChainConfigFromFile(filepath.Join(MustMakeChainDataDir(ctx), "chain.json"))
+	if err != nil {
+		panic(err)
+	}
+	config.Genesis = cc.Genesis
+	config.ChainConfig.Automine = true
+
+	return nil
+}

cmd/geth/flag.go

@@ -197,6 +197,9 @@ func mustMakeChainIdentity(ctx *cli.Context) (identity string) {
 		}
 		// glog.V(logger.Debug).Infof("No existing file at --%v: '%v'. Using literal chain identity.", aliasableName(ChainIdentityFlag.Name, ctx), chainFlagVal)
 		identity = chainFlagVal
+
+		glog.Error("parse chain identity", identity)
+
 		return identity
 	} else if ctx.GlobalIsSet(aliasableName(ChainIdentityFlag.Name, ctx)) {
 		glog.Fatalf("%v: %v: chainID empty", ErrInvalidFlag, core.ErrInvalidChainID)
@@ -478,6 +481,13 @@ func MakeSystemNode(version string, ctx *cli.Context) *node.Node {
 		miner.HeaderExtra = []byte(s)
 	}
 
+	if ctx.GlobalBool(EZDevModeFlag.Name) {
+		setEZDevFlags(ctx)
+		if err := setupEZDev(ctx, core.DefaultConfigEZDev); err != nil {
+			panic(err)
+		}
+	}
+
 	// Makes sufficient configuration from JSON file or DB pending flags.
 	// Delegates flag usage.
 	config := mustMakeSufficientChainConfig(ctx)
@@ -691,6 +701,12 @@ func mustMakeSufficientChainConfig(ctx *cli.Context) *core.SufficientChainConfig
 			state.StartingNonce = state.DefaultTestnetStartingNonce // (2**20)
 		}
 		return config
+	} else if ctx.GlobalBool(EZDevModeFlag.Name) {
+		c := core.DefaultConfigEZDev
+		if c.State != nil {
+			state.StartingNonce = c.State.StartingNonce
+		}
+		return c
 	}
 
 	// Returns surely valid suff chain config.
@@ -707,6 +723,7 @@ func mustMakeSufficientChainConfig(ctx *cli.Context) *core.SufficientChainConfig
 		`, core.ErrChainConfigNotFound, defaultChainConfigPath,
 			chainDir, chainIdentity, chainDir, chainDir)
 	}
+	glog.D(logger.Warn).Infoln("Reading chain config from", defaultChainConfigPath)
 	config, err := core.ReadExternalChainConfigFromFile(defaultChainConfigPath)
 	if err != nil {
 		glog.Fatalf(`invalid external configuration JSON: '%v': %v

cmd/geth/flags.go

@@ -66,6 +66,10 @@ var (
 		Name:  "dev",
 		Usage: "Developer mode: pre-configured private network with several debugging flags",
 	}
+	EZDevModeFlag = cli.BoolFlag{
+		Name:  "ezdev",
+		Usage: "EZ Developer mode: pre-configured private network, automining, default accounts",
+	}
 	NodeNameFlag = cli.StringFlag{
 		Name:  "identity,name",
 		Usage: "Custom node name",

cmd/geth/log_context.go

@@ -12,10 +12,11 @@ import (
 	"os"
 	"path/filepath"
 
+	"net"
+
 	"github.com/ethereumproject/go-ethereum/logger"
 	"github.com/ethereumproject/go-ethereum/logger/glog"
 	"github.com/ethereumproject/go-ethereum/p2p/discover"
-	"net"
 )
 
 const defaultStatusLog = "sync=60s"
@@ -54,7 +55,7 @@ func setupLogging(ctx *cli.Context) error {
 			glog.SetToStderr(true)
 		}
 	} else {
-		logDir = filepath.Join(MustMakeChainDataDir(ctx), glog.DefaultLogDirName)
+		logDir = filepath.Join(mustMakeDataDir(ctx), mustMakeChainIdentity(ctx), glog.DefaultLogDirName)
 	}
 
 	// Allow to-file logging to be disabled

cmd/geth/log_display_basic.go

@@ -57,7 +57,7 @@ var basicDisplaySystem = displayEventHandlers{
 				switch d := evData.(type) {
 				case core.NewMinedBlockEvent:
 					glog.D(logger.Warn).Infof(basicScanLn,
-						"Mined",
+						"Mined "+d.Stat.String(),
 						formatBlockNumber(d.Block.NumberU64()),
 						d.Block.Hash().Hex()[2:2+len(xlocalHeadHashD)],
 						fmt.Sprintf("%3d/%2d", d.Block.Transactions().Len(), new(big.Int).Div(d.Block.GasUsed(), big.NewInt(1000000)).Int64()),

cmd/geth/main.go

@@ -189,6 +189,7 @@ func makeCLIApp() (app *cli.App) {
 		PreloadJSFlag,
 		WhisperEnabledFlag,
 		DevModeFlag,
+		EZDevModeFlag,
 		TestNetFlag,
 		NetworkIdFlag,
 		RPCCORSDomainFlag,
@@ -263,21 +264,6 @@ func makeCLIApp() (app *cli.App) {
 		if err := handleIfDataDirSchemaMigrations(ctx); err != nil {
 			return err
 		}
-
-		if err := setupLogRotation(ctx); err != nil {
-			return err
-		}
-
-		// Handle parsing and applying log verbosity, severities, and default configurations from context.
-		if err := setupLogging(ctx); err != nil {
-			return err
-		}
-
-		// Handle parsing and applying log rotation configs from context.
-		if err := setupLogRotation(ctx); err != nil {
-			return err
-		}
-
 		if s := ctx.String("metrics"); s != "" {
 			go metrics.CollectToFile(s)
 		}
@@ -292,12 +278,27 @@ func makeCLIApp() (app *cli.App) {
 		// Set morden chain by default for dev mode.
 		if ctx.GlobalBool(aliasableName(DevModeFlag.Name, ctx)) {
 			if !ctx.GlobalIsSet(aliasableName(ChainIdentityFlag.Name, ctx)) {
-				if e := ctx.Set(aliasableName(ChainIdentityFlag.Name, ctx), "morden"); e != nil {
+				if e := ctx.GlobalSet(ChainIdentityFlag.Name, "morden"); e != nil {
 					return fmt.Errorf("failed to set chain value: %v", e)
 				}
 			}
 		}
 
+		if ctx.GlobalBool(aliasableName(EZDevModeFlag.Name, ctx)) {
+			log.Println("Turning on EZDEV...")
+			core.SetCacheChainIdentity("ezdev")
+		}
+
+		// Handle parsing and applying log verbosity, severities, and default configurations from context.
+		if err := setupLogging(ctx); err != nil {
+			return err
+		}
+
+		// Handle parsing and applying log rotation configs from context.
+		if err := setupLogRotation(ctx); err != nil {
+			return err
+		}
+
 		if port := ctx.GlobalInt(PprofFlag.Name); port != 0 {
 			interval := 5 * time.Second
 			if i := ctx.GlobalInt(PprofIntervalFlag.Name); i > 0 {