aboutsummaryrefslogtreecommitdiffstats
path: root/cmd/ethereum
diff options
context:
space:
mode:
Diffstat (limited to 'cmd/ethereum')
-rw-r--r--cmd/ethereum/flags.go168
-rw-r--r--cmd/ethereum/js.go (renamed from cmd/ethereum/cmd.go)13
-rw-r--r--cmd/ethereum/main.go238
3 files changed, 156 insertions, 263 deletions
diff --git a/cmd/ethereum/flags.go b/cmd/ethereum/flags.go
deleted file mode 100644
index a3004f503..000000000
--- a/cmd/ethereum/flags.go
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- This file is part of go-ethereum
-
- go-ethereum is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- go-ethereum is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @authors
- * Jeffrey Wilcke <i@jev.io>
- */
-package main
-
-import (
- "crypto/ecdsa"
- "flag"
- "fmt"
- "log"
- "os"
- "path"
- "runtime"
-
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethutil"
- "github.com/ethereum/go-ethereum/logger"
- "github.com/ethereum/go-ethereum/p2p/nat"
- "github.com/ethereum/go-ethereum/vm"
-)
-
-var (
- Identifier string
- KeyRing string
- DiffTool bool
- DiffType string
- KeyStore string
- StartRpc bool
- StartWebSockets bool
- RpcListenAddress string
- RpcPort int
- OutboundPort string
- ShowGenesis bool
- AddPeer string
- MaxPeer int
- GenAddr bool
- BootNodes string
- NodeKey *ecdsa.PrivateKey
- NAT nat.Interface
- SecretFile string
- ExportDir string
- NonInteractive bool
- Datadir string
- LogFile string
- ConfigFile string
- DebugFile string
- LogLevel int
- LogFormat string
- Dump bool
- DumpHash string
- DumpNumber int
- VmType int
- ImportChain string
- SHH bool
- Dial bool
- PrintVersion bool
- MinerThreads int
-)
-
-// flags specific to cli client
-var (
- StartMining bool
- StartJsConsole bool
- InputFile string
-)
-
-var defaultConfigFile = path.Join(ethutil.DefaultDataDir(), "conf.ini")
-
-func Init() {
- // TODO: move common flag processing to cmd/util
- flag.Usage = func() {
- fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line\n", os.Args[0])
- flag.PrintDefaults()
- }
-
- flag.IntVar(&VmType, "vm", 0, "Virtual Machine type: 0-1: standard, debug")
- flag.StringVar(&Identifier, "id", "", "Custom client identifier")
- flag.StringVar(&KeyRing, "keyring", "", "identifier for keyring to use")
- flag.StringVar(&KeyStore, "keystore", "db", "system to store keyrings: db|file")
-
- flag.StringVar(&RpcListenAddress, "rpcaddr", "127.0.0.1", "address for json-rpc server to listen on")
- flag.IntVar(&RpcPort, "rpcport", 8545, "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(&GenAddr, "genaddr", false, "create a new priv/pub key")
- flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
- flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
- flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
- flag.StringVar(&Datadir, "datadir", ethutil.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(logger.InfoLevel), "loglevel: 0-5 (= silent,error,warn,info,debug,debug detail)")
- flag.StringVar(&LogFormat, "logformat", "std", "logformat: std,raw")
- flag.BoolVar(&DiffTool, "difftool", false, "creates output for diff'ing. Sets LogLevel=0")
- flag.StringVar(&DiffType, "diff", "all", "sets the level of diff output [vm, all]. Has no effect if difftool=false")
- flag.BoolVar(&ShowGenesis, "genesis", false, "Dump the genesis block")
- flag.StringVar(&ImportChain, "chain", "", "Imports given chain")
-
- flag.BoolVar(&Dump, "dump", false, "output the ethereum state in JSON format. Sub args [number, hash]")
- flag.StringVar(&DumpHash, "hash", "", "specify arg in hex")
- flag.IntVar(&DumpNumber, "number", -1, "specify arg in number")
-
- flag.BoolVar(&StartMining, "mine", false, "start mining")
- flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console")
- flag.BoolVar(&PrintVersion, "version", false, "prints version number")
- flag.IntVar(&MinerThreads, "minerthreads", runtime.NumCPU(), "number of miner threads")
-
- // Network stuff
- var (
- nodeKeyFile = flag.String("nodekey", "", "network private key file")
- nodeKeyHex = flag.String("nodekeyhex", "", "network private key (for testing)")
- natstr = flag.String("nat", "any", "port mapping mechanism (any|none|upnp|pmp|extip:<IP>)")
- )
- flag.BoolVar(&Dial, "dial", true, "dial out connections (default on)")
- //flag.BoolVar(&SHH, "shh", true, "run whisper protocol (default on)")
- flag.StringVar(&OutboundPort, "port", "30303", "listening port")
-
- flag.StringVar(&BootNodes, "bootnodes", "", "space-separated node URLs for discovery bootstrap")
- flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
-
- flag.Parse()
-
- // When the javascript console is started log to a file instead
- // of stdout
- if StartJsConsole {
- LogFile = path.Join(Datadir, "ethereum.log")
- }
-
- var err error
- if NAT, err = nat.Parse(*natstr); err != nil {
- log.Fatalf("-nat: %v", err)
- }
- switch {
- case *nodeKeyFile != "" && *nodeKeyHex != "":
- log.Fatal("Options -nodekey and -nodekeyhex are mutually exclusive")
- case *nodeKeyFile != "":
- if NodeKey, err = crypto.LoadECDSA(*nodeKeyFile); err != nil {
- log.Fatalf("-nodekey: %v", err)
- }
- case *nodeKeyHex != "":
- if NodeKey, err = crypto.HexToECDSA(*nodeKeyHex); err != nil {
- log.Fatalf("-nodekeyhex: %v", err)
- }
- }
-
- if VmType >= int(vm.MaxVmTy) {
- log.Fatal("Invalid VM type ", VmType)
- }
-
- InputFile = flag.Arg(0)
-}
diff --git a/cmd/ethereum/cmd.go b/cmd/ethereum/js.go
index 7bb7c3ef7..f0aeb45f5 100644
--- a/cmd/ethereum/cmd.go
+++ b/cmd/ethereum/js.go
@@ -21,20 +21,23 @@ import (
"io/ioutil"
"os"
+ "github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/javascript"
"github.com/ethereum/go-ethereum/xeth"
)
-func ExecJsFile(ethereum *eth.Ethereum, InputFile string) {
- file, err := os.Open(InputFile)
+func execJsFile(ethereum *eth.Ethereum, filename string) {
+ file, err := os.Open(filename)
if err != nil {
- clilogger.Fatalln(err)
+ utils.Fatalf("%v", err)
}
content, err := ioutil.ReadAll(file)
if err != nil {
- clilogger.Fatalln(err)
+ utils.Fatalf("%v", err)
}
re := javascript.NewJSRE(xeth.New(ethereum))
- re.Run(string(content))
+ if _, err := re.Run(string(content)); err != nil {
+ utils.Fatalf("Javascript Error: %v", err)
+ }
}
diff --git a/cmd/ethereum/main.go b/cmd/ethereum/main.go
index b9e69f700..a38e012c2 100644
--- a/cmd/ethereum/main.go
+++ b/cmd/ethereum/main.go
@@ -24,15 +24,16 @@ import (
"fmt"
"os"
"runtime"
+ "strconv"
"time"
+ "github.com/codegangsta/cli"
"github.com/ethereum/go-ethereum/cmd/ethereum/repl"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/logger"
- "github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/state"
)
@@ -41,117 +42,174 @@ const (
Version = "0.8.6"
)
-var clilogger = logger.NewLogger("CLI")
+var (
+ clilogger = logger.NewLogger("CLI")
+ app = cli.NewApp()
+)
-func main() {
- runtime.GOMAXPROCS(runtime.NumCPU())
+func init() {
+ app.Version = Version
+ app.Usage = "the go-ethereum command-line client"
+ app.Action = run
+ app.HideVersion = true // we have a command to print the version
+ app.Commands = []cli.Command{
+ {
+ Action: version,
+ Name: "version",
+ Usage: "print ethereum version numbers",
+ Description: `
+The output of this command is supposed to be machine-readable.
+`,
+ },
+ {
+ Action: dump,
+ Name: "dump",
+ Usage: `dump a specific block from storage`,
+ Description: `
+The arguments are interpreted as block numbers or hashes.
+Use "ethereum dump 0" to dump the genesis block.
+`,
+ },
+ {
+ Action: runjs,
+ Name: "js",
+ Usage: `interactive JavaScript console`,
+ Description: `
+In the console, you can use the eth object to interact
+with the running ethereum stack. The API does not match
+ethereum.js.
+
+A JavaScript file can be provided as the argument. The
+runtime will execute the file and exit.
+`,
+ },
+ {
+ Action: importchain,
+ Name: "import",
+ Usage: `import a blockchain file`,
+ },
+ }
+ app.Author = ""
+ app.Email = ""
+ app.Flags = []cli.Flag{
+ utils.BootnodesFlag,
+ utils.DataDirFlag,
+ utils.KeyRingFlag,
+ utils.KeyStoreFlag,
+ utils.ListenPortFlag,
+ utils.LogFileFlag,
+ utils.LogFormatFlag,
+ utils.LogLevelFlag,
+ utils.MaxPeersFlag,
+ utils.MinerThreadsFlag,
+ utils.MiningEnabledFlag,
+ utils.NATFlag,
+ utils.NodeKeyFileFlag,
+ utils.NodeKeyHexFlag,
+ utils.RPCEnabledFlag,
+ utils.RPCListenAddrFlag,
+ utils.RPCPortFlag,
+ utils.VMTypeFlag,
+ }
+
+ // missing:
+ // flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
+ // flag.BoolVar(&DiffTool, "difftool", false, "creates output for diff'ing. Sets LogLevel=0")
+ // flag.StringVar(&DiffType, "diff", "all", "sets the level of diff output [vm, all]. Has no effect if difftool=false")
- defer func() {
- logger.Flush()
- }()
+ // potential subcommands:
+ // flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
+ // flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
+ // flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
+}
+func main() {
+ runtime.GOMAXPROCS(runtime.NumCPU())
+ defer logger.Flush()
utils.HandleInterrupt()
+ if err := app.Run(os.Args); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+}
- // precedence: code-internal flag default < config file < environment variables < command line
- Init() // parsing command line
+func run(ctx *cli.Context) {
+ fmt.Printf("Welcome to the FRONTIER\n")
+ eth := utils.GetEthereum(ClientIdentifier, Version, ctx)
+ startEth(ctx, eth)
+ // this blocks the thread
+ eth.WaitForShutdown()
+}
- if PrintVersion {
- printVersion()
- return
+func runjs(ctx *cli.Context) {
+ eth := utils.GetEthereum(ClientIdentifier, Version, ctx)
+ startEth(ctx, eth)
+ if len(ctx.Args()) == 0 {
+ repl := ethrepl.NewJSRepl(eth)
+ repl.Start()
+ utils.RegisterInterrupt(func(os.Signal) { repl.Stop() })
+ eth.WaitForShutdown()
+ } else if len(ctx.Args()) == 1 {
+ execJsFile(eth, ctx.Args()[0])
+ } else {
+ utils.Fatalf("This command can handle at most one argument.")
}
+}
- utils.InitConfig(VmType, ConfigFile, Datadir, "ETH")
-
- ethereum, err := eth.New(&eth.Config{
- Name: p2p.MakeName(ClientIdentifier, Version),
- KeyStore: KeyStore,
- DataDir: Datadir,
- LogFile: LogFile,
- LogLevel: LogLevel,
- LogFormat: LogFormat,
- MaxPeers: MaxPeer,
- Port: OutboundPort,
- NAT: NAT,
- KeyRing: KeyRing,
- Shh: true,
- Dial: Dial,
- BootNodes: BootNodes,
- NodeKey: NodeKey,
- MinerThreads: MinerThreads,
- })
+func startEth(ctx *cli.Context, eth *eth.Ethereum) {
+ utils.StartEthereum(eth)
+ if ctx.GlobalBool(utils.RPCEnabledFlag.Name) {
+ addr := ctx.GlobalString(utils.RPCListenAddrFlag.Name)
+ port := ctx.GlobalInt(utils.RPCPortFlag.Name)
+ utils.StartRpc(eth, addr, port)
+ }
+ if ctx.GlobalBool(utils.MiningEnabledFlag.Name) {
+ eth.Miner().Start()
+ }
+}
+func importchain(ctx *cli.Context) {
+ if len(ctx.Args()) != 1 {
+ utils.Fatalf("This command requires an argument.")
+ }
+ chain, _ := utils.GetChain(ctx)
+ start := time.Now()
+ err := utils.ImportChain(chain, ctx.Args().First())
if err != nil {
- clilogger.Fatalln(err)
+ utils.Fatalf("Import error: %v\n", err)
}
+ fmt.Printf("Import done in", time.Since(start))
+ return
+}
- utils.KeyTasks(ethereum.KeyManager(), KeyRing, GenAddr, SecretFile, ExportDir, NonInteractive)
-
- if Dump {
+func dump(ctx *cli.Context) {
+ chain, db := utils.GetChain(ctx)
+ for _, arg := range ctx.Args() {
var block *types.Block
-
- if len(DumpHash) == 0 && DumpNumber == -1 {
- block = ethereum.ChainManager().CurrentBlock()
- } else if len(DumpHash) > 0 {
- block = ethereum.ChainManager().GetBlock(ethutil.Hex2Bytes(DumpHash))
+ if hashish(arg) {
+ block = chain.GetBlock(ethutil.Hex2Bytes(arg))
} else {
- block = ethereum.ChainManager().GetBlockByNumber(uint64(DumpNumber))
+ num, _ := strconv.Atoi(arg)
+ block = chain.GetBlockByNumber(uint64(num))
}
-
if block == nil {
- fmt.Fprintln(os.Stderr, "block not found")
-
- // We want to output valid JSON
fmt.Println("{}")
-
- os.Exit(1)
- }
-
- // Leave the Println. This needs clean output for piping
- statedb := state.New(block.Root(), ethereum.Db())
- fmt.Printf("%s\n", statedb.Dump())
-
- fmt.Println(block)
-
- return
- }
-
- if len(ImportChain) > 0 {
- start := time.Now()
- err := utils.ImportChain(ethereum, ImportChain)
- if err != nil {
- clilogger.Infoln(err)
+ utils.Fatalf("block not found")
+ } else {
+ statedb := state.New(block.Root(), db)
+ fmt.Printf("%s\n", statedb.Dump())
+ // fmt.Println(block)
}
- clilogger.Infoln("import done in", time.Since(start))
- return
- }
-
- if StartRpc {
- utils.StartRpc(ethereum, RpcListenAddress, RpcPort)
- }
-
- utils.StartEthereum(ethereum)
-
- fmt.Printf("Welcome to the FRONTIER\n")
-
- if StartMining {
- ethereum.Miner().Start()
}
+}
- if StartJsConsole {
- repl := ethrepl.NewJSRepl(ethereum)
- repl.Start()
- utils.RegisterInterrupt(func(os.Signal) {
- repl.Stop()
- })
-
- } else if len(InputFile) > 0 {
- ExecJsFile(ethereum, InputFile)
- }
- // this blocks the thread
- ethereum.WaitForShutdown()
+// hashish returns true for strings that look like hashes.
+func hashish(x string) bool {
+ _, err := strconv.Atoi(x)
+ return err != nil
}
-func printVersion() {
+func version(c *cli.Context) {
fmt.Printf(`%v %v
PV=%d
GOOS=%s
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-26 09:15:46 +0800