eb21c652c0
Removes the yolov2 definition, adds yolov3, including EIP-2565. This PR also disables some of the erroneously generated blockchain and statetests, and adds the new genesis hash + alloc for yolov3. This PR disables the CLI switches for yolo, since it's not complete until we merge support for 2930.
233 lines
7.3 KiB
Go
233 lines
7.3 KiB
Go
// Copyright 2016 The go-ethereum Authors
|
|
// 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/>.
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/signal"
|
|
"path/filepath"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/ethereum/go-ethereum/cmd/utils"
|
|
"github.com/ethereum/go-ethereum/console"
|
|
"github.com/ethereum/go-ethereum/node"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
"gopkg.in/urfave/cli.v1"
|
|
)
|
|
|
|
var (
|
|
consoleFlags = []cli.Flag{utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag}
|
|
|
|
consoleCommand = cli.Command{
|
|
Action: utils.MigrateFlags(localConsole),
|
|
Name: "console",
|
|
Usage: "Start an interactive JavaScript environment",
|
|
Flags: append(append(append(nodeFlags, rpcFlags...), consoleFlags...), whisperFlags...),
|
|
Category: "CONSOLE COMMANDS",
|
|
Description: `
|
|
The Geth console is an interactive shell for the JavaScript runtime environment
|
|
which exposes a node admin interface as well as the Ðapp JavaScript API.
|
|
See https://geth.ethereum.org/docs/interface/javascript-console.`,
|
|
}
|
|
|
|
attachCommand = cli.Command{
|
|
Action: utils.MigrateFlags(remoteConsole),
|
|
Name: "attach",
|
|
Usage: "Start an interactive JavaScript environment (connect to node)",
|
|
ArgsUsage: "[endpoint]",
|
|
Flags: append(consoleFlags, utils.DataDirFlag),
|
|
Category: "CONSOLE COMMANDS",
|
|
Description: `
|
|
The Geth console is an interactive shell for the JavaScript runtime environment
|
|
which exposes a node admin interface as well as the Ðapp JavaScript API.
|
|
See https://geth.ethereum.org/docs/interface/javascript-console.
|
|
This command allows to open a console on a running geth node.`,
|
|
}
|
|
|
|
javascriptCommand = cli.Command{
|
|
Action: utils.MigrateFlags(ephemeralConsole),
|
|
Name: "js",
|
|
Usage: "Execute the specified JavaScript files",
|
|
ArgsUsage: "<jsfile> [jsfile...]",
|
|
Flags: append(nodeFlags, consoleFlags...),
|
|
Category: "CONSOLE COMMANDS",
|
|
Description: `
|
|
The JavaScript VM exposes a node admin interface as well as the Ðapp
|
|
JavaScript API. See https://geth.ethereum.org/docs/interface/javascript-console`,
|
|
}
|
|
)
|
|
|
|
// localConsole starts a new geth node, attaching a JavaScript console to it at the
|
|
// same time.
|
|
func localConsole(ctx *cli.Context) error {
|
|
// Create and start the node based on the CLI flags
|
|
prepare(ctx)
|
|
stack, backend := makeFullNode(ctx)
|
|
startNode(ctx, stack, backend)
|
|
defer stack.Close()
|
|
|
|
// Attach to the newly started node and start the JavaScript console
|
|
client, err := stack.Attach()
|
|
if err != nil {
|
|
utils.Fatalf("Failed to attach to the inproc geth: %v", err)
|
|
}
|
|
config := console.Config{
|
|
DataDir: utils.MakeDataDir(ctx),
|
|
DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
|
|
Client: client,
|
|
Preload: utils.MakeConsolePreloads(ctx),
|
|
}
|
|
|
|
console, err := console.New(config)
|
|
if err != nil {
|
|
utils.Fatalf("Failed to start the JavaScript console: %v", err)
|
|
}
|
|
defer console.Stop(false)
|
|
|
|
// If only a short execution was requested, evaluate and return
|
|
if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
|
|
console.Evaluate(script)
|
|
return nil
|
|
}
|
|
// Otherwise print the welcome screen and enter interactive mode
|
|
console.Welcome()
|
|
console.Interactive()
|
|
|
|
return nil
|
|
}
|
|
|
|
// remoteConsole will connect to a remote geth instance, attaching a JavaScript
|
|
// console to it.
|
|
func remoteConsole(ctx *cli.Context) error {
|
|
// Attach to a remotely running geth instance and start the JavaScript console
|
|
endpoint := ctx.Args().First()
|
|
if endpoint == "" {
|
|
path := node.DefaultDataDir()
|
|
if ctx.GlobalIsSet(utils.DataDirFlag.Name) {
|
|
path = ctx.GlobalString(utils.DataDirFlag.Name)
|
|
}
|
|
if path != "" {
|
|
if ctx.GlobalBool(utils.LegacyTestnetFlag.Name) || ctx.GlobalBool(utils.RopstenFlag.Name) {
|
|
// Maintain compatibility with older Geth configurations storing the
|
|
// Ropsten database in `testnet` instead of `ropsten`.
|
|
legacyPath := filepath.Join(path, "testnet")
|
|
if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
|
|
path = legacyPath
|
|
} else {
|
|
path = filepath.Join(path, "ropsten")
|
|
}
|
|
} else if ctx.GlobalBool(utils.RinkebyFlag.Name) {
|
|
path = filepath.Join(path, "rinkeby")
|
|
} else if ctx.GlobalBool(utils.GoerliFlag.Name) {
|
|
path = filepath.Join(path, "goerli")
|
|
} else if ctx.GlobalBool(utils.YoloV3Flag.Name) {
|
|
path = filepath.Join(path, "yolo-v3")
|
|
}
|
|
}
|
|
endpoint = fmt.Sprintf("%s/geth.ipc", path)
|
|
}
|
|
client, err := dialRPC(endpoint)
|
|
if err != nil {
|
|
utils.Fatalf("Unable to attach to remote geth: %v", err)
|
|
}
|
|
config := console.Config{
|
|
DataDir: utils.MakeDataDir(ctx),
|
|
DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
|
|
Client: client,
|
|
Preload: utils.MakeConsolePreloads(ctx),
|
|
}
|
|
|
|
console, err := console.New(config)
|
|
if err != nil {
|
|
utils.Fatalf("Failed to start the JavaScript console: %v", err)
|
|
}
|
|
defer console.Stop(false)
|
|
|
|
if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
|
|
console.Evaluate(script)
|
|
return nil
|
|
}
|
|
|
|
// Otherwise print the welcome screen and enter interactive mode
|
|
console.Welcome()
|
|
console.Interactive()
|
|
|
|
return nil
|
|
}
|
|
|
|
// dialRPC returns a RPC client which connects to the given endpoint.
|
|
// The check for empty endpoint implements the defaulting logic
|
|
// for "geth attach" and "geth monitor" with no argument.
|
|
func dialRPC(endpoint string) (*rpc.Client, error) {
|
|
if endpoint == "" {
|
|
endpoint = node.DefaultIPCEndpoint(clientIdentifier)
|
|
} else if strings.HasPrefix(endpoint, "rpc:") || strings.HasPrefix(endpoint, "ipc:") {
|
|
// Backwards compatibility with geth < 1.5 which required
|
|
// these prefixes.
|
|
endpoint = endpoint[4:]
|
|
}
|
|
return rpc.Dial(endpoint)
|
|
}
|
|
|
|
// ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript
|
|
// console to it, executes each of the files specified as arguments and tears
|
|
// everything down.
|
|
func ephemeralConsole(ctx *cli.Context) error {
|
|
// Create and start the node based on the CLI flags
|
|
stack, backend := makeFullNode(ctx)
|
|
startNode(ctx, stack, backend)
|
|
defer stack.Close()
|
|
|
|
// Attach to the newly started node and start the JavaScript console
|
|
client, err := stack.Attach()
|
|
if err != nil {
|
|
utils.Fatalf("Failed to attach to the inproc geth: %v", err)
|
|
}
|
|
config := console.Config{
|
|
DataDir: utils.MakeDataDir(ctx),
|
|
DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
|
|
Client: client,
|
|
Preload: utils.MakeConsolePreloads(ctx),
|
|
}
|
|
|
|
console, err := console.New(config)
|
|
if err != nil {
|
|
utils.Fatalf("Failed to start the JavaScript console: %v", err)
|
|
}
|
|
defer console.Stop(false)
|
|
|
|
// Evaluate each of the specified JavaScript files
|
|
for _, file := range ctx.Args() {
|
|
if err = console.Execute(file); err != nil {
|
|
utils.Fatalf("Failed to execute %s: %v", file, err)
|
|
}
|
|
}
|
|
// Wait for pending callbacks, but stop for Ctrl-C.
|
|
abort := make(chan os.Signal, 1)
|
|
signal.Notify(abort, syscall.SIGINT, syscall.SIGTERM)
|
|
|
|
go func() {
|
|
<-abort
|
|
os.Exit(0)
|
|
}()
|
|
console.Stop(true)
|
|
|
|
return nil
|
|
}
|