mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-25 13:07:17 +00:00
3b9808f23c
The blockchain commands don't need the full stack. With this change, p2p, miner, downloader, etc are no longer started for blockchain operations.
373 lines
11 KiB
Go
373 lines
11 KiB
Go
package utils
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"fmt"
|
|
"log"
|
|
"math/big"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
|
|
"github.com/codegangsta/cli"
|
|
"github.com/ethereum/ethash"
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"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/event"
|
|
"github.com/ethereum/go-ethereum/logger"
|
|
"github.com/ethereum/go-ethereum/logger/glog"
|
|
"github.com/ethereum/go-ethereum/p2p/nat"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
"github.com/ethereum/go-ethereum/xeth"
|
|
)
|
|
|
|
func init() {
|
|
cli.AppHelpTemplate = `{{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} [command options]{{end}} [arguments...]
|
|
|
|
VERSION:
|
|
{{.Version}}
|
|
|
|
COMMANDS:
|
|
{{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
|
|
{{end}}{{if .Flags}}
|
|
GLOBAL OPTIONS:
|
|
{{range .Flags}}{{.}}
|
|
{{end}}{{end}}
|
|
`
|
|
|
|
cli.CommandHelpTemplate = `{{.Name}}{{if .Subcommands}} command{{end}}{{if .Flags}} [command options]{{end}} [arguments...]
|
|
{{if .Description}}{{.Description}}
|
|
{{end}}{{if .Subcommands}}
|
|
SUBCOMMANDS:
|
|
{{range .Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
|
|
{{end}}{{end}}{{if .Flags}}
|
|
OPTIONS:
|
|
{{range .Flags}}{{.}}
|
|
{{end}}{{end}}
|
|
`
|
|
}
|
|
|
|
// NewApp creates an app with sane defaults.
|
|
func NewApp(version, usage string) *cli.App {
|
|
app := cli.NewApp()
|
|
app.Name = filepath.Base(os.Args[0])
|
|
app.Author = ""
|
|
//app.Authors = nil
|
|
app.Email = ""
|
|
app.Version = version
|
|
app.Usage = usage
|
|
return app
|
|
}
|
|
|
|
// 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
|
|
DataDirFlag = DirectoryFlag{
|
|
Name: "datadir",
|
|
Usage: "Data directory to be used",
|
|
Value: DirectoryString{common.DefaultDataDir()},
|
|
}
|
|
ProtocolVersionFlag = cli.IntFlag{
|
|
Name: "protocolversion",
|
|
Usage: "ETH protocol version (integer)",
|
|
Value: eth.ProtocolVersion,
|
|
}
|
|
NetworkIdFlag = cli.IntFlag{
|
|
Name: "networkid",
|
|
Usage: "Network Id (integer)",
|
|
Value: eth.NetworkId,
|
|
}
|
|
BlockchainVersionFlag = cli.IntFlag{
|
|
Name: "blockchainversion",
|
|
Usage: "Blockchain version (integer)",
|
|
Value: core.BlockChainVersion,
|
|
}
|
|
IdentityFlag = cli.StringFlag{
|
|
Name: "identity",
|
|
Usage: "Custom node name",
|
|
}
|
|
NatspecEnabledFlag = cli.BoolFlag{
|
|
Name: "natspec",
|
|
Usage: "Enable NatSpec confirmation notice",
|
|
}
|
|
|
|
// miner settings
|
|
MinerThreadsFlag = cli.IntFlag{
|
|
Name: "minerthreads",
|
|
Usage: "Number of miner threads",
|
|
Value: runtime.NumCPU(),
|
|
}
|
|
MiningEnabledFlag = cli.BoolFlag{
|
|
Name: "mine",
|
|
Usage: "Enable mining",
|
|
}
|
|
AutoDAGFlag = cli.BoolFlag{
|
|
Name: "autodag",
|
|
Usage: "Enable automatic DAG pregeneration",
|
|
}
|
|
EtherbaseFlag = cli.StringFlag{
|
|
Name: "etherbase",
|
|
Usage: "Public address for block mining rewards. By default the address of your primary account is used",
|
|
Value: "primary",
|
|
}
|
|
GasPriceFlag = cli.StringFlag{
|
|
Name: "gasprice",
|
|
Usage: "Sets the minimal gasprice when mining transactions",
|
|
Value: new(big.Int).Mul(big.NewInt(10), common.Szabo).String(),
|
|
}
|
|
|
|
UnlockedAccountFlag = cli.StringFlag{
|
|
Name: "unlock",
|
|
Usage: "Unlock the account given until this program exits (prompts for password). '--unlock primary' unlocks the primary account",
|
|
Value: "",
|
|
}
|
|
PasswordFileFlag = cli.StringFlag{
|
|
Name: "password",
|
|
Usage: "Path to password file to use with options and subcommands needing a password",
|
|
Value: "",
|
|
}
|
|
|
|
// logging and debug settings
|
|
LogFileFlag = cli.StringFlag{
|
|
Name: "logfile",
|
|
Usage: "Send log output to a file",
|
|
}
|
|
VerbosityFlag = cli.IntFlag{
|
|
Name: "verbosity",
|
|
Usage: "Logging verbosity: 0-6 (0=silent, 1=error, 2=warn, 3=info, 4=core, 5=debug, 6=debug detail)",
|
|
Value: int(logger.InfoLevel),
|
|
}
|
|
LogJSONFlag = cli.StringFlag{
|
|
Name: "logjson",
|
|
Usage: "Send json structured log output to a file or '-' for standard output (default: no json output)",
|
|
Value: "",
|
|
}
|
|
LogToStdErrFlag = cli.BoolFlag{
|
|
Name: "logtostderr",
|
|
Usage: "Logs are written to standard error instead of to files.",
|
|
}
|
|
LogVModuleFlag = cli.GenericFlag{
|
|
Name: "vmodule",
|
|
Usage: "The syntax of the argument is a comma-separated list of pattern=N, where pattern is a literal file name (minus the \".go\" suffix) or \"glob\" pattern and N is a log verbosity level.",
|
|
Value: glog.GetVModule(),
|
|
}
|
|
VMDebugFlag = cli.BoolFlag{
|
|
Name: "vmdebug",
|
|
Usage: "Virtual Machine debug output",
|
|
}
|
|
BacktraceAtFlag = cli.GenericFlag{
|
|
Name: "backtrace_at",
|
|
Usage: "If set to a file and line number (e.g., \"block.go:271\") holding a logging statement, a stack trace will be logged",
|
|
Value: glog.GetTraceLocation(),
|
|
}
|
|
PProfEanbledFlag = cli.BoolFlag{
|
|
Name: "pprof",
|
|
Usage: "Enable the profiling server on localhost",
|
|
}
|
|
PProfPortFlag = cli.IntFlag{
|
|
Name: "pprofport",
|
|
Usage: "Port on which the profiler should listen",
|
|
Value: 6060,
|
|
}
|
|
|
|
// RPC settings
|
|
RPCEnabledFlag = cli.BoolFlag{
|
|
Name: "rpc",
|
|
Usage: "Enable the JSON-RPC server",
|
|
}
|
|
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,
|
|
}
|
|
RPCCORSDomainFlag = cli.StringFlag{
|
|
Name: "rpccorsdomain",
|
|
Usage: "Domain on which to send Access-Control-Allow-Origin header",
|
|
Value: "",
|
|
}
|
|
// Network Settings
|
|
MaxPeersFlag = cli.IntFlag{
|
|
Name: "maxpeers",
|
|
Usage: "Maximum number of network peers (network disabled if set to 0)",
|
|
Value: 25,
|
|
}
|
|
MaxPendingPeersFlag = cli.IntFlag{
|
|
Name: "maxpendpeers",
|
|
Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
|
|
Value: 0,
|
|
}
|
|
ListenPortFlag = cli.IntFlag{
|
|
Name: "port",
|
|
Usage: "Network listening port",
|
|
Value: 30303,
|
|
}
|
|
BootnodesFlag = cli.StringFlag{
|
|
Name: "bootnodes",
|
|
Usage: "Space-separated enode URLs for p2p 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: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
|
|
Value: "any",
|
|
}
|
|
NoDiscoverFlag = cli.BoolFlag{
|
|
Name: "nodiscover",
|
|
Usage: "Disables the peer discovery mechanism (manual peer addition)",
|
|
}
|
|
WhisperEnabledFlag = cli.BoolFlag{
|
|
Name: "shh",
|
|
Usage: "Enable whisper",
|
|
}
|
|
// ATM the url is left to the user and deployment to
|
|
JSpathFlag = cli.StringFlag{
|
|
Name: "jspath",
|
|
Usage: "JS library path to be used with console and js subcommands",
|
|
Value: ".",
|
|
}
|
|
SolcPathFlag = cli.StringFlag{
|
|
Name: "solc",
|
|
Usage: "solidity compiler to be used",
|
|
Value: "solc",
|
|
}
|
|
)
|
|
|
|
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 MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config {
|
|
customName := ctx.GlobalString(IdentityFlag.Name)
|
|
if len(customName) > 0 {
|
|
clientID += "/" + customName
|
|
}
|
|
return ð.Config{
|
|
Name: common.MakeName(clientID, version),
|
|
DataDir: ctx.GlobalString(DataDirFlag.Name),
|
|
ProtocolVersion: ctx.GlobalInt(ProtocolVersionFlag.Name),
|
|
BlockChainVersion: ctx.GlobalInt(BlockchainVersionFlag.Name),
|
|
SkipBcVersionCheck: false,
|
|
NetworkId: ctx.GlobalInt(NetworkIdFlag.Name),
|
|
LogFile: ctx.GlobalString(LogFileFlag.Name),
|
|
Verbosity: ctx.GlobalInt(VerbosityFlag.Name),
|
|
LogJSON: ctx.GlobalString(LogJSONFlag.Name),
|
|
Etherbase: ctx.GlobalString(EtherbaseFlag.Name),
|
|
MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name),
|
|
AccountManager: GetAccountManager(ctx),
|
|
VmDebug: ctx.GlobalBool(VMDebugFlag.Name),
|
|
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
|
MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
|
|
Port: ctx.GlobalString(ListenPortFlag.Name),
|
|
NAT: GetNAT(ctx),
|
|
NatSpec: ctx.GlobalBool(NatspecEnabledFlag.Name),
|
|
Discovery: !ctx.GlobalBool(NoDiscoverFlag.Name),
|
|
NodeKey: GetNodeKey(ctx),
|
|
Shh: ctx.GlobalBool(WhisperEnabledFlag.Name),
|
|
Dial: true,
|
|
BootNodes: ctx.GlobalString(BootnodesFlag.Name),
|
|
GasPrice: common.String2Big(ctx.GlobalString(GasPriceFlag.Name)),
|
|
SolcPath: ctx.GlobalString(SolcPathFlag.Name),
|
|
AutoDAG: ctx.GlobalBool(AutoDAGFlag.Name) || ctx.GlobalBool(MiningEnabledFlag.Name),
|
|
}
|
|
}
|
|
|
|
// SetupLogger configures glog from the logging-related command line flags.
|
|
func SetupLogger(ctx *cli.Context) {
|
|
glog.SetV(ctx.GlobalInt(VerbosityFlag.Name))
|
|
glog.CopyStandardLogTo("INFO")
|
|
glog.SetToStderr(true)
|
|
glog.SetLogDir(ctx.GlobalString(LogFileFlag.Name))
|
|
}
|
|
|
|
func GetChain(ctx *cli.Context) (chain *core.ChainManager, blockDB, stateDB, extraDB common.Database) {
|
|
dd := ctx.GlobalString(DataDirFlag.Name)
|
|
var err error
|
|
if blockDB, err = ethdb.NewLDBDatabase(filepath.Join(dd, "blockchain")); err != nil {
|
|
Fatalf("Could not open database: %v", err)
|
|
}
|
|
if stateDB, err = ethdb.NewLDBDatabase(filepath.Join(dd, "state")); err != nil {
|
|
Fatalf("Could not open database: %v", err)
|
|
}
|
|
if extraDB, err = ethdb.NewLDBDatabase(filepath.Join(dd, "extra")); err != nil {
|
|
Fatalf("Could not open database: %v", err)
|
|
}
|
|
|
|
eventMux := new(event.TypeMux)
|
|
pow := ethash.New()
|
|
chain = core.NewChainManager(blockDB, stateDB, pow, eventMux)
|
|
txpool := core.NewTxPool(eventMux, chain.State, chain.GasLimit)
|
|
proc := core.NewBlockProcessor(stateDB, extraDB, pow, txpool, chain, eventMux)
|
|
chain.SetProcessor(proc)
|
|
return chain, blockDB, stateDB, extraDB
|
|
}
|
|
|
|
func GetAccountManager(ctx *cli.Context) *accounts.Manager {
|
|
dataDir := ctx.GlobalString(DataDirFlag.Name)
|
|
ks := crypto.NewKeyStorePassphrase(filepath.Join(dataDir, "keystore"))
|
|
return accounts.NewManager(ks)
|
|
}
|
|
|
|
func StartRPC(eth *eth.Ethereum, ctx *cli.Context) error {
|
|
config := rpc.RpcConfig{
|
|
ListenAddress: ctx.GlobalString(RPCListenAddrFlag.Name),
|
|
ListenPort: uint(ctx.GlobalInt(RPCPortFlag.Name)),
|
|
CorsDomain: ctx.GlobalString(RPCCORSDomainFlag.Name),
|
|
}
|
|
|
|
xeth := xeth.New(eth, nil)
|
|
return rpc.Start(xeth, config)
|
|
}
|
|
|
|
func StartPProf(ctx *cli.Context) {
|
|
address := fmt.Sprintf("localhost:%d", ctx.GlobalInt(PProfPortFlag.Name))
|
|
go func() {
|
|
log.Println(http.ListenAndServe(address, nil))
|
|
}()
|
|
}
|