2015-07-06 17:54:22 -07:00
|
|
|
// Copyright 2015 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
|
2015-07-22 09:48:40 -07:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-06 17:54:22 -07:00
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
2015-07-22 09:48:40 -07:00
|
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-06 17:54:22 -07:00
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// Package utils contains internal helper functions for go-ethereum commands.
|
2015-03-05 18:00:41 -08:00
|
|
|
package utils
|
|
|
|
|
|
|
|
import (
|
|
|
|
"crypto/ecdsa"
|
2015-04-20 08:45:37 -07:00
|
|
|
"fmt"
|
2015-11-17 08:33:25 -08:00
|
|
|
"io/ioutil"
|
2015-05-09 03:00:51 -07:00
|
|
|
"math/big"
|
2015-03-09 15:00:27 -07:00
|
|
|
"os"
|
2015-05-12 05:24:11 -07:00
|
|
|
"path/filepath"
|
2015-07-07 01:32:05 -07:00
|
|
|
"strconv"
|
2015-11-17 08:33:25 -08:00
|
|
|
"strings"
|
2015-05-12 05:24:11 -07:00
|
|
|
|
2015-03-07 03:39:52 -08:00
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
2015-03-18 00:44:58 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2018-05-23 22:32:26 -07:00
|
|
|
"github.com/ethereum/go-ethereum/common/fdlimit"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/consensus"
|
|
|
|
"github.com/ethereum/go-ethereum/consensus/clique"
|
|
|
|
"github.com/ethereum/go-ethereum/consensus/ethash"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2015-11-17 08:33:25 -08:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
2018-05-23 22:32:26 -07:00
|
|
|
"github.com/ethereum/go-ethereum/dashboard"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/eth"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/eth/downloader"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/gasprice"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/ethstats"
|
|
|
|
"github.com/ethereum/go-ethereum/les"
|
|
|
|
"github.com/ethereum/go-ethereum/log"
|
2015-08-07 00:56:49 -07:00
|
|
|
"github.com/ethereum/go-ethereum/metrics"
|
2018-07-02 05:51:02 -07:00
|
|
|
"github.com/ethereum/go-ethereum/metrics/influxdb"
|
2015-11-17 08:33:25 -08:00
|
|
|
"github.com/ethereum/go-ethereum/node"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/p2p"
|
|
|
|
"github.com/ethereum/go-ethereum/p2p/discv5"
|
all: new p2p node representation (#17643)
Package p2p/enode provides a generalized representation of p2p nodes
which can contain arbitrary information in key/value pairs. It is also
the new home for the node database. The "v4" identity scheme is also
moved here from p2p/enr to remove the dependency on Ethereum crypto from
that package.
Record signature handling is changed significantly. The identity scheme
registry is removed and acceptable schemes must be passed to any method
that needs identity. This means records must now be validated explicitly
after decoding.
The enode API is designed to make signature handling easy and safe: most
APIs around the codebase work with enode.Node, which is a wrapper around
a valid record. Going from enr.Record to enode.Node requires a valid
signature.
* p2p/discover: port to p2p/enode
This ports the discovery code to the new node representation in
p2p/enode. The wire protocol is unchanged, this can be considered a
refactoring change. The Kademlia table can now deal with nodes using an
arbitrary identity scheme. This requires a few incompatible API changes:
- Table.Lookup is not available anymore. It used to take a public key
as argument because v4 protocol requires one. Its replacement is
LookupRandom.
- Table.Resolve takes *enode.Node instead of NodeID. This is also for
v4 protocol compatibility because nodes cannot be looked up by ID
alone.
- Types Node and NodeID are gone. Further commits in the series will be
fixes all over the the codebase to deal with those removals.
* p2p: port to p2p/enode and discovery changes
This adapts package p2p to the changes in p2p/discover. All uses of
discover.Node and discover.NodeID are replaced by their equivalents from
p2p/enode.
New API is added to retrieve the enode.Node instance of a peer. The
behavior of Server.Self with discovery disabled is improved. It now
tries much harder to report a working IP address, falling back to
127.0.0.1 if no suitable address can be determined through other means.
These changes were needed for tests of other packages later in the
series.
* p2p/simulations, p2p/testing: port to p2p/enode
No surprises here, mostly replacements of discover.Node, discover.NodeID
with their new equivalents. The 'interesting' API changes are:
- testing.ProtocolSession tracks complete nodes, not just their IDs.
- adapters.NodeConfig has a new method to create a complete node.
These changes were needed to make swarm tests work.
Note that the NodeID change makes the code incompatible with old
simulation snapshots.
* whisper/whisperv5, whisper/whisperv6: port to p2p/enode
This port was easy because whisper uses []byte for node IDs and
URL strings in the API.
* eth: port to p2p/enode
Again, easy to port because eth uses strings for node IDs and doesn't
care about node information in any way.
* les: port to p2p/enode
Apart from replacing discover.NodeID with enode.ID, most changes are in
the server pool code. It now deals with complete nodes instead
of (Pubkey, IP, Port) triples. The database format is unchanged for now,
but we should probably change it to use the node database later.
* node: port to p2p/enode
This change simply replaces discover.Node and discover.NodeID with their
new equivalents.
* swarm/network: port to p2p/enode
Swarm has its own node address representation, BzzAddr, containing both
an overlay address (the hash of a secp256k1 public key) and an underlay
address (enode:// URL).
There are no changes to the BzzAddr format in this commit, but certain
operations such as creating a BzzAddr from a node ID are now impossible
because node IDs aren't public keys anymore.
Most swarm-related changes in the series remove uses of
NewAddrFromNodeID, replacing it with NewAddr which takes a complete node
as argument. ToOverlayAddr is removed because we can just use the node
ID directly.
2018-09-24 15:59:00 -07:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/enode"
|
2015-03-05 18:00:41 -08:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/nat"
|
2017-10-31 15:24:11 -07:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/netutil"
|
2015-10-07 08:21:13 -07:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2018-05-23 22:32:26 -07:00
|
|
|
whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
|
2016-06-09 02:44:42 -07:00
|
|
|
"gopkg.in/urfave/cli.v1"
|
2018-07-24 01:15:38 -07:00
|
|
|
"time"
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
var (
|
|
|
|
CommandHelpTemplate = `{{.cmd.Name}}{{if .cmd.Subcommands}} command{{end}}{{if .cmd.Flags}} [command options]{{end}} [arguments...]
|
|
|
|
{{if .cmd.Description}}{{.cmd.Description}}
|
|
|
|
{{end}}{{if .cmd.Subcommands}}
|
|
|
|
SUBCOMMANDS:
|
2018-05-23 22:32:26 -07:00
|
|
|
{{range .cmd.Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
|
2017-10-31 15:24:11 -07:00
|
|
|
{{end}}{{end}}{{if .categorizedFlags}}
|
|
|
|
{{range $idx, $categorized := .categorizedFlags}}{{$categorized.Name}} OPTIONS:
|
|
|
|
{{range $categorized.Flags}}{{"\t"}}{{.}}
|
|
|
|
{{end}}
|
|
|
|
{{end}}{{end}}`
|
|
|
|
)
|
|
|
|
|
2015-03-10 08:44:48 -07:00
|
|
|
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}}
|
|
|
|
`
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
cli.CommandHelpTemplate = CommandHelpTemplate
|
2015-03-10 08:44:48 -07:00
|
|
|
}
|
|
|
|
|
2015-03-09 14:51:50 -07:00
|
|
|
// NewApp creates an app with sane defaults.
|
2016-09-05 04:08:41 -07:00
|
|
|
func NewApp(gitCommit, usage string) *cli.App {
|
2015-03-09 14:51:50 -07:00
|
|
|
app := cli.NewApp()
|
2015-05-12 05:24:11 -07:00
|
|
|
app.Name = filepath.Base(os.Args[0])
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Author = ""
|
2015-03-25 17:03:03 -07:00
|
|
|
//app.Authors = nil
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Email = ""
|
2018-07-30 01:56:40 -07:00
|
|
|
app.Version = params.VersionWithMeta
|
2018-05-23 22:32:26 -07:00
|
|
|
if len(gitCommit) >= 8 {
|
2016-09-05 04:08:41 -07:00
|
|
|
app.Version += "-" + gitCommit[:8]
|
|
|
|
}
|
2015-03-09 14:51:50 -07:00
|
|
|
app.Usage = usage
|
|
|
|
return app
|
|
|
|
}
|
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
// 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
|
2015-04-08 06:43:55 -07:00
|
|
|
DataDirFlag = DirectoryFlag{
|
2015-03-05 18:00:41 -08:00
|
|
|
Name: "datadir",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Data directory for the databases and keystore",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: DirectoryString{node.DefaultDataDir()},
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2016-03-07 14:38:56 -08:00
|
|
|
KeyStoreDirFlag = DirectoryFlag{
|
|
|
|
Name: "keystore",
|
|
|
|
Usage: "Directory for the keystore (default = inside the datadir)",
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
NoUSBFlag = cli.BoolFlag{
|
|
|
|
Name: "nousb",
|
|
|
|
Usage: "Disables monitoring for and managing USB hardware wallets",
|
2015-03-18 00:44:58 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
NetworkIdFlag = cli.Uint64Flag{
|
|
|
|
Name: "networkid",
|
|
|
|
Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby, 5=Ottoman)",
|
|
|
|
Value: eth.DefaultConfig.NetworkId,
|
2015-06-08 03:12:13 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
TestnetFlag = cli.BoolFlag{
|
2015-10-29 10:53:24 -07:00
|
|
|
Name: "testnet",
|
2017-10-31 15:24:11 -07:00
|
|
|
Usage: "Ropsten network: pre-configured proof-of-work test network",
|
|
|
|
}
|
|
|
|
RinkebyFlag = cli.BoolFlag{
|
|
|
|
Name: "rinkeby",
|
|
|
|
Usage: "Rinkeby network: pre-configured proof-of-authority test network",
|
|
|
|
}
|
|
|
|
OttomanFlag = cli.BoolFlag{
|
|
|
|
Name: "ottoman",
|
|
|
|
Usage: "Ottoman network: pre-configured istanbul bft test network",
|
2015-07-10 05:29:40 -07:00
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
DeveloperFlag = cli.BoolFlag{
|
2015-09-06 06:46:54 -07:00
|
|
|
Name: "dev",
|
2018-05-23 22:32:26 -07:00
|
|
|
Usage: "Ephemeral proof-of-authority network with a pre-funded developer account, mining enabled",
|
|
|
|
}
|
|
|
|
DeveloperPeriodFlag = cli.IntFlag{
|
|
|
|
Name: "dev.period",
|
|
|
|
Usage: "Block period to use in developer mode (0 = mine only if transaction pending)",
|
2015-09-06 06:46:54 -07:00
|
|
|
}
|
2015-04-18 14:53:30 -07:00
|
|
|
IdentityFlag = cli.StringFlag{
|
|
|
|
Name: "identity",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Custom node name",
|
2015-04-18 14:53:30 -07:00
|
|
|
}
|
2015-10-26 14:24:09 -07:00
|
|
|
DocRootFlag = DirectoryFlag{
|
|
|
|
Name: "docroot",
|
|
|
|
Usage: "Document Root for HTTPClient file scheme",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: DirectoryString{homeDir()},
|
2015-10-26 14:24:09 -07:00
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
defaultSyncMode = eth.DefaultConfig.SyncMode
|
|
|
|
SyncModeFlag = TextMarshalerFlag{
|
|
|
|
Name: "syncmode",
|
|
|
|
Usage: `Blockchain sync mode ("fast", "full", or "light")`,
|
|
|
|
Value: &defaultSyncMode,
|
|
|
|
}
|
|
|
|
GCModeFlag = cli.StringFlag{
|
|
|
|
Name: "gcmode",
|
|
|
|
Usage: `Blockchain garbage collection mode ("full", "archive")`,
|
|
|
|
Value: "full",
|
|
|
|
}
|
|
|
|
LightServFlag = cli.IntFlag{
|
|
|
|
Name: "lightserv",
|
|
|
|
Usage: "Maximum percentage of time allowed for serving LES requests (0-90)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
|
|
|
LightPeersFlag = cli.IntFlag{
|
|
|
|
Name: "lightpeers",
|
|
|
|
Usage: "Maximum number of LES client peers",
|
|
|
|
Value: eth.DefaultConfig.LightPeers,
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2015-10-23 07:49:36 -07:00
|
|
|
LightKDFFlag = cli.BoolFlag{
|
|
|
|
Name: "lightkdf",
|
2015-11-10 05:47:19 -08:00
|
|
|
Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
|
2015-10-23 07:49:36 -07:00
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
// Dashboard settings
|
|
|
|
DashboardEnabledFlag = cli.BoolFlag{
|
cmd, dashboard, log: log collection and exploration (#17097)
* cmd, dashboard, internal, log, node: logging feature
* cmd, dashboard, internal, log: requested changes
* dashboard, vendor: gofmt, govendor, use vendored file watcher
* dashboard, log: gofmt -s -w, goimports
* dashboard, log: gosimple
2018-07-11 00:59:04 -07:00
|
|
|
Name: metrics.DashboardEnabledFlag,
|
2018-05-23 22:32:26 -07:00
|
|
|
Usage: "Enable the dashboard",
|
|
|
|
}
|
|
|
|
DashboardAddrFlag = cli.StringFlag{
|
|
|
|
Name: "dashboard.addr",
|
|
|
|
Usage: "Dashboard listening interface",
|
|
|
|
Value: dashboard.DefaultConfig.Host,
|
|
|
|
}
|
|
|
|
DashboardPortFlag = cli.IntFlag{
|
|
|
|
Name: "dashboard.host",
|
|
|
|
Usage: "Dashboard listening port",
|
|
|
|
Value: dashboard.DefaultConfig.Port,
|
|
|
|
}
|
|
|
|
DashboardRefreshFlag = cli.DurationFlag{
|
|
|
|
Name: "dashboard.refresh",
|
|
|
|
Usage: "Dashboard metrics collection refresh rate",
|
|
|
|
Value: dashboard.DefaultConfig.Refresh,
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
// Ethash settings
|
|
|
|
EthashCacheDirFlag = DirectoryFlag{
|
|
|
|
Name: "ethash.cachedir",
|
|
|
|
Usage: "Directory to store the ethash verification caches (default = inside the datadir)",
|
|
|
|
}
|
|
|
|
EthashCachesInMemoryFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.cachesinmem",
|
|
|
|
Usage: "Number of recent ethash caches to keep in memory (16MB each)",
|
2018-05-23 22:32:26 -07:00
|
|
|
Value: eth.DefaultConfig.Ethash.CachesInMem,
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
EthashCachesOnDiskFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.cachesondisk",
|
|
|
|
Usage: "Number of recent ethash caches to keep on disk (16MB each)",
|
2018-05-23 22:32:26 -07:00
|
|
|
Value: eth.DefaultConfig.Ethash.CachesOnDisk,
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
EthashDatasetDirFlag = DirectoryFlag{
|
|
|
|
Name: "ethash.dagdir",
|
|
|
|
Usage: "Directory to store the ethash mining DAGs (default = inside home folder)",
|
2018-05-23 22:32:26 -07:00
|
|
|
Value: DirectoryString{eth.DefaultConfig.Ethash.DatasetDir},
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
EthashDatasetsInMemoryFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.dagsinmem",
|
|
|
|
Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)",
|
2018-05-23 22:32:26 -07:00
|
|
|
Value: eth.DefaultConfig.Ethash.DatasetsInMem,
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
EthashDatasetsOnDiskFlag = cli.IntFlag{
|
|
|
|
Name: "ethash.dagsondisk",
|
|
|
|
Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)",
|
2018-05-23 22:32:26 -07:00
|
|
|
Value: eth.DefaultConfig.Ethash.DatasetsOnDisk,
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
// Transaction pool settings
|
2018-08-21 10:30:06 -07:00
|
|
|
TxPoolLocalsFlag = cli.StringFlag{
|
|
|
|
Name: "txpool.locals",
|
|
|
|
Usage: "Comma separated accounts to treat as locals (no flush, priority inclusion)",
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
TxPoolNoLocalsFlag = cli.BoolFlag{
|
|
|
|
Name: "txpool.nolocals",
|
|
|
|
Usage: "Disables price exemptions for locally submitted transactions",
|
|
|
|
}
|
|
|
|
TxPoolJournalFlag = cli.StringFlag{
|
|
|
|
Name: "txpool.journal",
|
|
|
|
Usage: "Disk journal for local transaction to survive node restarts",
|
|
|
|
Value: core.DefaultTxPoolConfig.Journal,
|
|
|
|
}
|
|
|
|
TxPoolRejournalFlag = cli.DurationFlag{
|
|
|
|
Name: "txpool.rejournal",
|
|
|
|
Usage: "Time interval to regenerate the local transaction journal",
|
|
|
|
Value: core.DefaultTxPoolConfig.Rejournal,
|
|
|
|
}
|
|
|
|
TxPoolPriceLimitFlag = cli.Uint64Flag{
|
|
|
|
Name: "txpool.pricelimit",
|
|
|
|
Usage: "Minimum gas price limit to enforce for acceptance into the pool",
|
|
|
|
Value: eth.DefaultConfig.TxPool.PriceLimit,
|
|
|
|
}
|
|
|
|
TxPoolPriceBumpFlag = cli.Uint64Flag{
|
|
|
|
Name: "txpool.pricebump",
|
|
|
|
Usage: "Price bump percentage to replace an already existing transaction",
|
|
|
|
Value: eth.DefaultConfig.TxPool.PriceBump,
|
|
|
|
}
|
|
|
|
TxPoolAccountSlotsFlag = cli.Uint64Flag{
|
|
|
|
Name: "txpool.accountslots",
|
|
|
|
Usage: "Minimum number of executable transaction slots guaranteed per account",
|
|
|
|
Value: eth.DefaultConfig.TxPool.AccountSlots,
|
|
|
|
}
|
|
|
|
TxPoolGlobalSlotsFlag = cli.Uint64Flag{
|
|
|
|
Name: "txpool.globalslots",
|
|
|
|
Usage: "Maximum number of executable transaction slots for all accounts",
|
|
|
|
Value: eth.DefaultConfig.TxPool.GlobalSlots,
|
|
|
|
}
|
|
|
|
TxPoolAccountQueueFlag = cli.Uint64Flag{
|
|
|
|
Name: "txpool.accountqueue",
|
|
|
|
Usage: "Maximum number of non-executable transaction slots permitted per account",
|
|
|
|
Value: eth.DefaultConfig.TxPool.AccountQueue,
|
|
|
|
}
|
|
|
|
TxPoolGlobalQueueFlag = cli.Uint64Flag{
|
|
|
|
Name: "txpool.globalqueue",
|
|
|
|
Usage: "Maximum number of non-executable transaction slots for all accounts",
|
|
|
|
Value: eth.DefaultConfig.TxPool.GlobalQueue,
|
|
|
|
}
|
|
|
|
TxPoolLifetimeFlag = cli.DurationFlag{
|
|
|
|
Name: "txpool.lifetime",
|
|
|
|
Usage: "Maximum amount of time non-executable transaction are queued",
|
|
|
|
Value: eth.DefaultConfig.TxPool.Lifetime,
|
|
|
|
}
|
2016-10-19 04:55:13 -07:00
|
|
|
// Performance tuning settings
|
|
|
|
CacheFlag = cli.IntFlag{
|
|
|
|
Name: "cache",
|
2018-05-23 22:32:26 -07:00
|
|
|
Usage: "Megabytes of memory allocated to internal caching",
|
|
|
|
Value: 1024,
|
|
|
|
}
|
|
|
|
CacheDatabaseFlag = cli.IntFlag{
|
|
|
|
Name: "cache.database",
|
|
|
|
Usage: "Percentage of cache memory allowance to use for database io",
|
|
|
|
Value: 75,
|
|
|
|
}
|
|
|
|
CacheGCFlag = cli.IntFlag{
|
|
|
|
Name: "cache.gc",
|
|
|
|
Usage: "Percentage of cache memory allowance to use for trie pruning",
|
|
|
|
Value: 25,
|
2016-10-19 04:55:13 -07:00
|
|
|
}
|
|
|
|
TrieCacheGenFlag = cli.IntFlag{
|
|
|
|
Name: "trie-cache-gens",
|
|
|
|
Usage: "Number of trie node generations to keep in memory",
|
|
|
|
Value: int(state.MaxTrieCacheGen),
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
// Miner settings
|
|
|
|
MiningEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "mine",
|
|
|
|
Usage: "Enable mining",
|
|
|
|
}
|
|
|
|
MinerThreadsFlag = cli.IntFlag{
|
2018-08-08 02:15:08 -07:00
|
|
|
Name: "miner.threads",
|
2017-10-31 15:24:11 -07:00
|
|
|
Usage: "Number of CPU threads to use for mining",
|
2018-08-08 02:15:08 -07:00
|
|
|
Value: 0,
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerLegacyThreadsFlag = cli.IntFlag{
|
|
|
|
Name: "minerthreads",
|
|
|
|
Usage: "Number of CPU threads to use for mining (deprecated, use --miner.threads)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
2018-08-08 02:15:08 -07:00
|
|
|
MinerNotifyFlag = cli.StringFlag{
|
|
|
|
Name: "miner.notify",
|
|
|
|
Usage: "Comma separated HTTP URL list to notify of new work packages",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerGasTargetFlag = cli.Uint64Flag{
|
|
|
|
Name: "miner.gastarget",
|
|
|
|
Usage: "Target gas floor for mined blocks",
|
2018-08-29 02:21:12 -07:00
|
|
|
Value: eth.DefaultConfig.MinerGasFloor,
|
2018-08-15 01:01:49 -07:00
|
|
|
}
|
|
|
|
MinerLegacyGasTargetFlag = cli.Uint64Flag{
|
2016-03-01 14:32:43 -08:00
|
|
|
Name: "targetgaslimit",
|
2018-08-15 01:01:49 -07:00
|
|
|
Usage: "Target gas floor for mined blocks (deprecated, use --miner.gastarget)",
|
2018-08-29 02:21:12 -07:00
|
|
|
Value: eth.DefaultConfig.MinerGasFloor,
|
2015-05-20 08:56:17 -07:00
|
|
|
}
|
2018-08-29 02:21:12 -07:00
|
|
|
MinerGasLimitFlag = cli.Uint64Flag{
|
|
|
|
Name: "miner.gaslimit",
|
|
|
|
Usage: "Target gas ceiling for mined blocks",
|
|
|
|
Value: eth.DefaultConfig.MinerGasCeil,
|
2016-03-01 14:32:43 -08:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerGasPriceFlag = BigFlag{
|
|
|
|
Name: "miner.gasprice",
|
2018-09-10 05:22:34 -07:00
|
|
|
Usage: "Minimum gas price for mining a transaction",
|
2018-08-21 12:56:54 -07:00
|
|
|
Value: eth.DefaultConfig.MinerGasPrice,
|
2015-03-26 14:49:22 -07:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerLegacyGasPriceFlag = BigFlag{
|
2015-05-09 03:00:51 -07:00
|
|
|
Name: "gasprice",
|
2018-09-10 05:22:34 -07:00
|
|
|
Usage: "Minimum gas price for mining a transaction (deprecated, use --miner.gasprice)",
|
2018-08-21 12:56:54 -07:00
|
|
|
Value: eth.DefaultConfig.MinerGasPrice,
|
2015-05-09 03:00:51 -07:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerEtherbaseFlag = cli.StringFlag{
|
|
|
|
Name: "miner.etherbase",
|
|
|
|
Usage: "Public address for block mining rewards (default = first account)",
|
|
|
|
Value: "0",
|
|
|
|
}
|
|
|
|
MinerLegacyEtherbaseFlag = cli.StringFlag{
|
2015-03-27 04:14:00 -07:00
|
|
|
Name: "etherbase",
|
2018-08-15 01:01:49 -07:00
|
|
|
Usage: "Public address for block mining rewards (default = first account, deprecated, use --miner.etherbase)",
|
2015-07-07 01:32:05 -07:00
|
|
|
Value: "0",
|
2015-03-26 14:49:22 -07:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerExtraDataFlag = cli.StringFlag{
|
|
|
|
Name: "miner.extradata",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Block extra data set by the miner (default = client version)",
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
MinerLegacyExtraDataFlag = cli.StringFlag{
|
2015-09-22 01:34:58 -07:00
|
|
|
Name: "extradata",
|
2018-08-15 01:01:49 -07:00
|
|
|
Usage: "Block extra data set by the miner (default = client version, deprecated, use --miner.extradata)",
|
|
|
|
}
|
2018-08-21 12:56:54 -07:00
|
|
|
MinerRecommitIntervalFlag = cli.DurationFlag{
|
|
|
|
Name: "miner.recommit",
|
2018-08-28 06:59:05 -07:00
|
|
|
Usage: "Time interval to recreate the block being mined",
|
2018-08-21 23:47:50 -07:00
|
|
|
Value: eth.DefaultConfig.MinerRecommit,
|
2018-08-21 12:56:54 -07:00
|
|
|
}
|
2018-08-28 06:59:05 -07:00
|
|
|
MinerNoVerfiyFlag = cli.BoolFlag{
|
|
|
|
Name: "miner.noverify",
|
|
|
|
Usage: "Disable remote sealing verification",
|
2015-09-22 01:34:58 -07:00
|
|
|
}
|
2015-10-29 10:53:24 -07:00
|
|
|
// Account settings
|
2015-03-18 00:44:58 -07:00
|
|
|
UnlockedAccountFlag = cli.StringFlag{
|
|
|
|
Name: "unlock",
|
2015-11-17 08:33:25 -08:00
|
|
|
Usage: "Comma separated list of accounts to unlock",
|
2015-03-23 06:00:06 -07:00
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
PasswordFileFlag = cli.StringFlag{
|
|
|
|
Name: "password",
|
2017-10-31 15:24:11 -07:00
|
|
|
Usage: "Password file to use for non-interactive password input",
|
2015-03-23 06:00:06 -07:00
|
|
|
Value: "",
|
2015-03-18 00:44:58 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
VMEnableDebugFlag = cli.BoolFlag{
|
|
|
|
Name: "vmdebug",
|
|
|
|
Usage: "Record information useful for VM and contract debugging",
|
2015-07-17 14:09:36 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
// Logging and debug settings
|
|
|
|
EthStatsURLFlag = cli.StringFlag{
|
|
|
|
Name: "ethstats",
|
|
|
|
Usage: "Reporting URL of a ethstats service (nodename:secret@host:port)",
|
2015-07-17 14:09:36 -07:00
|
|
|
}
|
2016-04-21 02:14:57 -07:00
|
|
|
FakePoWFlag = cli.BoolFlag{
|
|
|
|
Name: "fakepow",
|
|
|
|
Usage: "Disables proof-of-work verification",
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
NoCompactionFlag = cli.BoolFlag{
|
|
|
|
Name: "nocompaction",
|
|
|
|
Usage: "Disables db compaction after import",
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
// RPC settings
|
|
|
|
RPCEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "rpc",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "Enable the HTTP-RPC server",
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
RPCListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "rpcaddr",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "HTTP-RPC server listening interface",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultHTTPHost,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
RPCPortFlag = cli.IntFlag{
|
|
|
|
Name: "rpcport",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "HTTP-RPC server listening port",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultHTTPPort,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-03-29 12:21:14 -07:00
|
|
|
RPCCORSDomainFlag = cli.StringFlag{
|
|
|
|
Name: "rpccorsdomain",
|
2016-02-24 02:19:00 -08:00
|
|
|
Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
|
2015-03-29 12:21:14 -07:00
|
|
|
Value: "",
|
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
RPCVirtualHostsFlag = cli.StringFlag{
|
|
|
|
Name: "rpcvhosts",
|
|
|
|
Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
|
|
|
|
Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
|
|
|
|
}
|
2015-12-16 01:58:01 -08:00
|
|
|
RPCApiFlag = cli.StringFlag{
|
2015-06-16 04:30:53 -07:00
|
|
|
Name: "rpcapi",
|
2015-10-29 10:53:24 -07:00
|
|
|
Usage: "API's offered over the HTTP-RPC interface",
|
2017-10-31 15:24:11 -07:00
|
|
|
Value: "",
|
2015-06-16 04:30:53 -07:00
|
|
|
}
|
2015-06-08 02:01:02 -07:00
|
|
|
IPCDisabledFlag = cli.BoolFlag{
|
|
|
|
Name: "ipcdisable",
|
|
|
|
Usage: "Disable the IPC-RPC server",
|
|
|
|
}
|
|
|
|
IPCPathFlag = DirectoryFlag{
|
|
|
|
Name: "ipcpath",
|
2016-02-02 09:06:43 -08:00
|
|
|
Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
|
2015-06-08 02:01:02 -07:00
|
|
|
}
|
2015-12-16 01:58:01 -08:00
|
|
|
WSEnabledFlag = cli.BoolFlag{
|
2016-01-26 05:39:21 -08:00
|
|
|
Name: "ws",
|
2015-12-16 01:58:01 -08:00
|
|
|
Usage: "Enable the WS-RPC server",
|
|
|
|
}
|
|
|
|
WSListenAddrFlag = cli.StringFlag{
|
|
|
|
Name: "wsaddr",
|
|
|
|
Usage: "WS-RPC server listening interface",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultWSHost,
|
2015-12-16 01:58:01 -08:00
|
|
|
}
|
|
|
|
WSPortFlag = cli.IntFlag{
|
|
|
|
Name: "wsport",
|
|
|
|
Usage: "WS-RPC server listening port",
|
2016-09-16 02:53:50 -07:00
|
|
|
Value: node.DefaultWSPort,
|
2015-12-16 01:58:01 -08:00
|
|
|
}
|
|
|
|
WSApiFlag = cli.StringFlag{
|
|
|
|
Name: "wsapi",
|
|
|
|
Usage: "API's offered over the WS-RPC interface",
|
2017-10-31 15:24:11 -07:00
|
|
|
Value: "",
|
2015-12-16 01:58:01 -08:00
|
|
|
}
|
2016-03-14 01:38:54 -07:00
|
|
|
WSAllowedOriginsFlag = cli.StringFlag{
|
|
|
|
Name: "wsorigins",
|
|
|
|
Usage: "Origins from which to accept websockets requests",
|
2015-12-16 01:58:01 -08:00
|
|
|
Value: "",
|
2015-10-15 07:07:19 -07:00
|
|
|
}
|
2015-06-19 05:04:18 -07:00
|
|
|
ExecFlag = cli.StringFlag{
|
|
|
|
Name: "exec",
|
2017-10-31 15:24:11 -07:00
|
|
|
Usage: "Execute JavaScript statement",
|
2015-06-19 05:04:18 -07:00
|
|
|
}
|
2016-05-06 02:40:23 -07:00
|
|
|
PreloadJSFlag = cli.StringFlag{
|
2016-04-07 04:48:24 -07:00
|
|
|
Name: "preload",
|
|
|
|
Usage: "Comma separated list of JavaScript files to preload into the console",
|
|
|
|
}
|
2016-01-26 05:39:21 -08:00
|
|
|
|
2015-03-05 18:00:41 -08:00
|
|
|
// Network Settings
|
|
|
|
MaxPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpeers",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "Maximum number of network peers (network disabled if set to 0)",
|
2015-05-08 07:01:31 -07:00
|
|
|
Value: 25,
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-05-04 07:35:49 -07:00
|
|
|
MaxPendingPeersFlag = cli.IntFlag{
|
|
|
|
Name: "maxpendpeers",
|
|
|
|
Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
|
|
|
|
Value: 0,
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
ListenPortFlag = cli.IntFlag{
|
|
|
|
Name: "port",
|
|
|
|
Usage: "Network listening port",
|
|
|
|
Value: 30303,
|
|
|
|
}
|
|
|
|
BootnodesFlag = cli.StringFlag{
|
|
|
|
Name: "bootnodes",
|
2017-10-31 15:24:11 -07:00
|
|
|
Usage: "Comma separated enode URLs for P2P discovery bootstrap (set v4+v5 instead for light servers)",
|
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
BootnodesV4Flag = cli.StringFlag{
|
|
|
|
Name: "bootnodesv4",
|
|
|
|
Usage: "Comma separated enode URLs for P2P v4 discovery bootstrap (light server, full nodes)",
|
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
BootnodesV5Flag = cli.StringFlag{
|
|
|
|
Name: "bootnodesv5",
|
|
|
|
Usage: "Comma separated enode URLs for P2P v5 discovery bootstrap (light server, light nodes)",
|
2015-03-05 18:00:41 -08:00
|
|
|
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",
|
2015-04-21 16:41:34 -07:00
|
|
|
Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
|
2015-03-05 18:00:41 -08:00
|
|
|
Value: "any",
|
|
|
|
}
|
2015-05-26 09:07:24 -07:00
|
|
|
NoDiscoverFlag = cli.BoolFlag{
|
|
|
|
Name: "nodiscover",
|
|
|
|
Usage: "Disables the peer discovery mechanism (manual peer addition)",
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
DiscoveryV5Flag = cli.BoolFlag{
|
|
|
|
Name: "v5disc",
|
|
|
|
Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
|
2015-04-20 08:45:37 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
NetrestrictFlag = cli.StringFlag{
|
|
|
|
Name: "netrestrict",
|
|
|
|
Usage: "Restricts network communication to the given IP networks (CIDR masks)",
|
|
|
|
}
|
|
|
|
|
2015-04-22 15:11:11 -07:00
|
|
|
// ATM the url is left to the user and deployment to
|
2015-03-14 23:31:40 -07:00
|
|
|
JSpathFlag = cli.StringFlag{
|
|
|
|
Name: "jspath",
|
2017-10-31 15:24:11 -07:00
|
|
|
Usage: "JavaScript root path for `loadScript`",
|
2015-03-14 23:31:40 -07:00
|
|
|
Value: ".",
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
|
|
|
|
// Gas price oracle settings
|
|
|
|
GpoBlocksFlag = cli.IntFlag{
|
|
|
|
Name: "gpoblocks",
|
|
|
|
Usage: "Number of recent blocks to check for gas prices",
|
|
|
|
Value: eth.DefaultConfig.GPO.Blocks,
|
2016-10-09 08:10:48 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
GpoPercentileFlag = cli.IntFlag{
|
|
|
|
Name: "gpopercentile",
|
|
|
|
Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices",
|
|
|
|
Value: eth.DefaultConfig.GPO.Percentile,
|
2016-10-09 08:10:48 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
WhisperEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: "shh",
|
|
|
|
Usage: "Enable Whisper",
|
2016-10-09 08:10:48 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
WhisperMaxMessageSizeFlag = cli.IntFlag{
|
|
|
|
Name: "shh.maxmessagesize",
|
|
|
|
Usage: "Max message size accepted",
|
|
|
|
Value: int(whisper.DefaultMaxMessageSize),
|
2016-10-09 08:10:48 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
WhisperMinPOWFlag = cli.Float64Flag{
|
|
|
|
Name: "shh.pow",
|
|
|
|
Usage: "Minimum POW accepted",
|
|
|
|
Value: whisper.DefaultMinimumPoW,
|
2016-11-17 15:50:28 -08:00
|
|
|
}
|
2018-09-05 01:57:45 -07:00
|
|
|
WhisperRestrictConnectionBetweenLightClientsFlag = cli.BoolFlag{
|
|
|
|
Name: "shh.restrict-light",
|
|
|
|
Usage: "Restrict connection between two whisper light clients",
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
|
2017-03-23 11:41:02 -07:00
|
|
|
// Raft flags
|
|
|
|
RaftModeFlag = cli.BoolFlag{
|
|
|
|
Name: "raft",
|
|
|
|
Usage: "If enabled, uses Raft instead of Quorum Chain for consensus",
|
|
|
|
}
|
2017-08-28 14:43:44 -07:00
|
|
|
RaftBlockTimeFlag = cli.IntFlag{
|
2017-03-23 11:41:02 -07:00
|
|
|
Name: "raftblocktime",
|
|
|
|
Usage: "Amount of time between raft block creations in milliseconds",
|
|
|
|
Value: 50,
|
|
|
|
}
|
2017-08-28 14:43:44 -07:00
|
|
|
RaftJoinExistingFlag = cli.IntFlag{
|
|
|
|
Name: "raftjoinexisting",
|
|
|
|
Usage: "The raft ID to assume when joining an pre-existing cluster",
|
|
|
|
Value: 0,
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
EmitCheckpointsFlag = cli.BoolFlag{
|
|
|
|
Name: "emitcheckpoints",
|
|
|
|
Usage: "If enabled, emit specially formatted logging checkpoints",
|
|
|
|
}
|
2017-08-28 14:43:44 -07:00
|
|
|
RaftPortFlag = cli.IntFlag{
|
|
|
|
Name: "raftport",
|
|
|
|
Usage: "The port to bind for the raft transport",
|
|
|
|
Value: 50400,
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
|
|
|
|
// Quorum
|
|
|
|
EnableNodePermissionFlag = cli.BoolFlag{
|
|
|
|
Name: "permissioned",
|
|
|
|
Usage: "If enabled, the node will allow only a defined list of nodes to connect",
|
|
|
|
}
|
|
|
|
|
2019-03-08 01:09:24 -08:00
|
|
|
// Quorum permission contract
|
|
|
|
PermissionContractAddressFlag = cli.StringFlag{
|
|
|
|
Name: "permission.contract",
|
|
|
|
Usage: "If passed, the node will use this contract to bootstrap permission instead of contract from genesis.json",
|
|
|
|
Value: "0x",
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// Istanbul settings
|
|
|
|
IstanbulRequestTimeoutFlag = cli.Uint64Flag{
|
|
|
|
Name: "istanbul.requesttimeout",
|
|
|
|
Usage: "Timeout for each Istanbul round in milliseconds",
|
|
|
|
Value: eth.DefaultConfig.Istanbul.RequestTimeout,
|
|
|
|
}
|
|
|
|
IstanbulBlockPeriodFlag = cli.Uint64Flag{
|
|
|
|
Name: "istanbul.blockperiod",
|
|
|
|
Usage: "Default minimum difference between two consecutive block's timestamps in seconds",
|
|
|
|
Value: eth.DefaultConfig.Istanbul.BlockPeriod,
|
|
|
|
}
|
2018-08-29 23:59:45 -07:00
|
|
|
|
|
|
|
// Metrics flags
|
|
|
|
MetricsEnabledFlag = cli.BoolFlag{
|
|
|
|
Name: metrics.MetricsEnabledFlag,
|
|
|
|
Usage: "Enable metrics collection and reporting",
|
|
|
|
}
|
|
|
|
MetricsEnableInfluxDBFlag = cli.BoolFlag{
|
|
|
|
Name: "metrics.influxdb",
|
|
|
|
Usage: "Enable metrics export/push to an external InfluxDB database",
|
|
|
|
}
|
|
|
|
MetricsInfluxDBEndpointFlag = cli.StringFlag{
|
|
|
|
Name: "metrics.influxdb.endpoint",
|
|
|
|
Usage: "InfluxDB API endpoint to report metrics to",
|
|
|
|
Value: "http://localhost:8086",
|
|
|
|
}
|
|
|
|
MetricsInfluxDBDatabaseFlag = cli.StringFlag{
|
|
|
|
Name: "metrics.influxdb.database",
|
|
|
|
Usage: "InfluxDB database name to push reported metrics to",
|
|
|
|
Value: "geth",
|
|
|
|
}
|
2018-07-02 05:51:02 -07:00
|
|
|
MetricsInfluxDBUsernameFlag = cli.StringFlag{
|
|
|
|
Name: "metrics.influxdb.username",
|
|
|
|
Usage: "Username to authorize access to the database",
|
|
|
|
Value: "test",
|
|
|
|
}
|
|
|
|
MetricsInfluxDBPasswordFlag = cli.StringFlag{
|
|
|
|
Name: "metrics.influxdb.password",
|
|
|
|
Usage: "Password to authorize access to the database",
|
|
|
|
Value: "test",
|
|
|
|
}
|
|
|
|
// The `host` tag is part of every measurement sent to InfluxDB. Queries on tags are faster in InfluxDB.
|
|
|
|
// It is used so that we can group all nodes and average a measurement across all of them, but also so
|
|
|
|
// that we can select a specific node and inspect its measurements.
|
|
|
|
// https://docs.influxdata.com/influxdb/v1.4/concepts/key_concepts/#tag-key
|
|
|
|
MetricsInfluxDBHostTagFlag = cli.StringFlag{
|
|
|
|
Name: "metrics.influxdb.host.tag",
|
|
|
|
Usage: "InfluxDB `host` tag attached to all measurements",
|
|
|
|
Value: "localhost",
|
|
|
|
}
|
2018-09-20 00:44:35 -07:00
|
|
|
|
|
|
|
EWASMInterpreterFlag = cli.StringFlag{
|
|
|
|
Name: "vm.ewasm",
|
|
|
|
Usage: "External ewasm configuration (default = built-in interpreter)",
|
|
|
|
Value: "",
|
|
|
|
}
|
|
|
|
EVMInterpreterFlag = cli.StringFlag{
|
|
|
|
Name: "vm.evm",
|
|
|
|
Usage: "External EVM configuration (default = built-in interpreter)",
|
|
|
|
Value: "",
|
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
)
|
|
|
|
|
2016-08-18 04:28:17 -07:00
|
|
|
// MakeDataDir retrieves the currently requested data directory, terminating
|
2015-11-17 08:33:25 -08:00
|
|
|
// if none (or the empty string) is specified. If the node is starting a testnet,
|
|
|
|
// the a subdirectory of the specified datadir will be used.
|
2016-08-18 04:28:17 -07:00
|
|
|
func MakeDataDir(ctx *cli.Context) string {
|
2015-11-17 08:33:25 -08:00
|
|
|
if path := ctx.GlobalString(DataDirFlag.Name); path != "" {
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalBool(TestnetFlag.Name) {
|
2016-08-18 04:28:17 -07:00
|
|
|
return filepath.Join(path, "testnet")
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalBool(RinkebyFlag.Name) {
|
|
|
|
return filepath.Join(path, "rinkeby")
|
|
|
|
}
|
|
|
|
if ctx.GlobalBool(OttomanFlag.Name) {
|
|
|
|
return filepath.Join(path, "ottoman")
|
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
return path
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
Fatalf("Cannot determine default data directory, please set manually (--datadir)")
|
|
|
|
return ""
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setNodeKey creates a node key from set command line flags, either loading it
|
2015-11-17 08:33:25 -08:00
|
|
|
// from a file or as a specified hex value. If neither flags were provided, this
|
|
|
|
// method returns nil and an emphemeral key is to be generated.
|
2017-10-31 15:24:11 -07:00
|
|
|
func setNodeKey(ctx *cli.Context, cfg *p2p.Config) {
|
2015-11-17 08:33:25 -08:00
|
|
|
var (
|
|
|
|
hex = ctx.GlobalString(NodeKeyHexFlag.Name)
|
|
|
|
file = ctx.GlobalString(NodeKeyFileFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
key *ecdsa.PrivateKey
|
|
|
|
err error
|
2015-11-17 08:33:25 -08:00
|
|
|
)
|
2015-03-05 18:00:41 -08:00
|
|
|
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)
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.PrivateKey = key
|
2015-03-05 18:00:41 -08:00
|
|
|
case hex != "":
|
|
|
|
if key, err = crypto.HexToECDSA(hex); err != nil {
|
|
|
|
Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.PrivateKey = key
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setNodeUserIdent creates the user identifier from CLI flags.
|
|
|
|
func setNodeUserIdent(ctx *cli.Context, cfg *node.Config) {
|
2015-11-17 08:33:25 -08:00
|
|
|
if identity := ctx.GlobalString(IdentityFlag.Name); len(identity) > 0 {
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.UserIdent = identity
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setBootstrapNodes creates a list of bootstrap nodes from the command line
|
2015-11-17 08:33:25 -08:00
|
|
|
// flags, reverting to pre-configured ones if none have been specified.
|
2017-10-31 15:24:11 -07:00
|
|
|
func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) {
|
|
|
|
urls := params.MainnetBootnodes
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalIsSet(BootnodesFlag.Name) || ctx.GlobalIsSet(BootnodesV4Flag.Name):
|
|
|
|
if ctx.GlobalIsSet(BootnodesV4Flag.Name) {
|
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesV4Flag.Name), ",")
|
|
|
|
} else {
|
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
case ctx.GlobalBool(TestnetFlag.Name):
|
|
|
|
urls = params.TestnetBootnodes
|
|
|
|
case ctx.GlobalBool(RinkebyFlag.Name):
|
|
|
|
urls = params.RinkebyBootnodes
|
|
|
|
case ctx.GlobalBool(OttomanFlag.Name):
|
|
|
|
urls = params.OttomanBootnodes
|
2018-05-23 22:32:26 -07:00
|
|
|
case cfg.BootstrapNodes != nil:
|
|
|
|
return // already set, don't apply defaults.
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
all: new p2p node representation (#17643)
Package p2p/enode provides a generalized representation of p2p nodes
which can contain arbitrary information in key/value pairs. It is also
the new home for the node database. The "v4" identity scheme is also
moved here from p2p/enr to remove the dependency on Ethereum crypto from
that package.
Record signature handling is changed significantly. The identity scheme
registry is removed and acceptable schemes must be passed to any method
that needs identity. This means records must now be validated explicitly
after decoding.
The enode API is designed to make signature handling easy and safe: most
APIs around the codebase work with enode.Node, which is a wrapper around
a valid record. Going from enr.Record to enode.Node requires a valid
signature.
* p2p/discover: port to p2p/enode
This ports the discovery code to the new node representation in
p2p/enode. The wire protocol is unchanged, this can be considered a
refactoring change. The Kademlia table can now deal with nodes using an
arbitrary identity scheme. This requires a few incompatible API changes:
- Table.Lookup is not available anymore. It used to take a public key
as argument because v4 protocol requires one. Its replacement is
LookupRandom.
- Table.Resolve takes *enode.Node instead of NodeID. This is also for
v4 protocol compatibility because nodes cannot be looked up by ID
alone.
- Types Node and NodeID are gone. Further commits in the series will be
fixes all over the the codebase to deal with those removals.
* p2p: port to p2p/enode and discovery changes
This adapts package p2p to the changes in p2p/discover. All uses of
discover.Node and discover.NodeID are replaced by their equivalents from
p2p/enode.
New API is added to retrieve the enode.Node instance of a peer. The
behavior of Server.Self with discovery disabled is improved. It now
tries much harder to report a working IP address, falling back to
127.0.0.1 if no suitable address can be determined through other means.
These changes were needed for tests of other packages later in the
series.
* p2p/simulations, p2p/testing: port to p2p/enode
No surprises here, mostly replacements of discover.Node, discover.NodeID
with their new equivalents. The 'interesting' API changes are:
- testing.ProtocolSession tracks complete nodes, not just their IDs.
- adapters.NodeConfig has a new method to create a complete node.
These changes were needed to make swarm tests work.
Note that the NodeID change makes the code incompatible with old
simulation snapshots.
* whisper/whisperv5, whisper/whisperv6: port to p2p/enode
This port was easy because whisper uses []byte for node IDs and
URL strings in the API.
* eth: port to p2p/enode
Again, easy to port because eth uses strings for node IDs and doesn't
care about node information in any way.
* les: port to p2p/enode
Apart from replacing discover.NodeID with enode.ID, most changes are in
the server pool code. It now deals with complete nodes instead
of (Pubkey, IP, Port) triples. The database format is unchanged for now,
but we should probably change it to use the node database later.
* node: port to p2p/enode
This change simply replaces discover.Node and discover.NodeID with their
new equivalents.
* swarm/network: port to p2p/enode
Swarm has its own node address representation, BzzAddr, containing both
an overlay address (the hash of a secp256k1 public key) and an underlay
address (enode:// URL).
There are no changes to the BzzAddr format in this commit, but certain
operations such as creating a BzzAddr from a node ID are now impossible
because node IDs aren't public keys anymore.
Most swarm-related changes in the series remove uses of
NewAddrFromNodeID, replacing it with NewAddr which takes a complete node
as argument. ToOverlayAddr is removed because we can just use the node
ID directly.
2018-09-24 15:59:00 -07:00
|
|
|
cfg.BootstrapNodes = make([]*enode.Node, 0, len(urls))
|
2017-10-31 15:24:11 -07:00
|
|
|
for _, url := range urls {
|
all: new p2p node representation (#17643)
Package p2p/enode provides a generalized representation of p2p nodes
which can contain arbitrary information in key/value pairs. It is also
the new home for the node database. The "v4" identity scheme is also
moved here from p2p/enr to remove the dependency on Ethereum crypto from
that package.
Record signature handling is changed significantly. The identity scheme
registry is removed and acceptable schemes must be passed to any method
that needs identity. This means records must now be validated explicitly
after decoding.
The enode API is designed to make signature handling easy and safe: most
APIs around the codebase work with enode.Node, which is a wrapper around
a valid record. Going from enr.Record to enode.Node requires a valid
signature.
* p2p/discover: port to p2p/enode
This ports the discovery code to the new node representation in
p2p/enode. The wire protocol is unchanged, this can be considered a
refactoring change. The Kademlia table can now deal with nodes using an
arbitrary identity scheme. This requires a few incompatible API changes:
- Table.Lookup is not available anymore. It used to take a public key
as argument because v4 protocol requires one. Its replacement is
LookupRandom.
- Table.Resolve takes *enode.Node instead of NodeID. This is also for
v4 protocol compatibility because nodes cannot be looked up by ID
alone.
- Types Node and NodeID are gone. Further commits in the series will be
fixes all over the the codebase to deal with those removals.
* p2p: port to p2p/enode and discovery changes
This adapts package p2p to the changes in p2p/discover. All uses of
discover.Node and discover.NodeID are replaced by their equivalents from
p2p/enode.
New API is added to retrieve the enode.Node instance of a peer. The
behavior of Server.Self with discovery disabled is improved. It now
tries much harder to report a working IP address, falling back to
127.0.0.1 if no suitable address can be determined through other means.
These changes were needed for tests of other packages later in the
series.
* p2p/simulations, p2p/testing: port to p2p/enode
No surprises here, mostly replacements of discover.Node, discover.NodeID
with their new equivalents. The 'interesting' API changes are:
- testing.ProtocolSession tracks complete nodes, not just their IDs.
- adapters.NodeConfig has a new method to create a complete node.
These changes were needed to make swarm tests work.
Note that the NodeID change makes the code incompatible with old
simulation snapshots.
* whisper/whisperv5, whisper/whisperv6: port to p2p/enode
This port was easy because whisper uses []byte for node IDs and
URL strings in the API.
* eth: port to p2p/enode
Again, easy to port because eth uses strings for node IDs and doesn't
care about node information in any way.
* les: port to p2p/enode
Apart from replacing discover.NodeID with enode.ID, most changes are in
the server pool code. It now deals with complete nodes instead
of (Pubkey, IP, Port) triples. The database format is unchanged for now,
but we should probably change it to use the node database later.
* node: port to p2p/enode
This change simply replaces discover.Node and discover.NodeID with their
new equivalents.
* swarm/network: port to p2p/enode
Swarm has its own node address representation, BzzAddr, containing both
an overlay address (the hash of a secp256k1 public key) and an underlay
address (enode:// URL).
There are no changes to the BzzAddr format in this commit, but certain
operations such as creating a BzzAddr from a node ID are now impossible
because node IDs aren't public keys anymore.
Most swarm-related changes in the series remove uses of
NewAddrFromNodeID, replacing it with NewAddr which takes a complete node
as argument. ToOverlayAddr is removed because we can just use the node
ID directly.
2018-09-24 15:59:00 -07:00
|
|
|
node, err := enode.ParseV4(url)
|
2015-11-17 08:33:25 -08:00
|
|
|
if err != nil {
|
2018-07-26 03:57:20 -07:00
|
|
|
log.Crit("Bootstrap URL invalid", "enode", url, "err", err)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.BootstrapNodes = append(cfg.BootstrapNodes, node)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setBootstrapNodesV5 creates a list of bootstrap nodes from the command line
|
|
|
|
// flags, reverting to pre-configured ones if none have been specified.
|
|
|
|
func setBootstrapNodesV5(ctx *cli.Context, cfg *p2p.Config) {
|
|
|
|
urls := params.DiscoveryV5Bootnodes
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalIsSet(BootnodesFlag.Name) || ctx.GlobalIsSet(BootnodesV5Flag.Name):
|
|
|
|
if ctx.GlobalIsSet(BootnodesV5Flag.Name) {
|
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesV5Flag.Name), ",")
|
|
|
|
} else {
|
|
|
|
urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
|
|
|
|
}
|
|
|
|
case ctx.GlobalBool(RinkebyFlag.Name):
|
2018-05-23 22:32:26 -07:00
|
|
|
urls = params.RinkebyBootnodes
|
2017-10-31 15:24:11 -07:00
|
|
|
case cfg.BootstrapNodesV5 != nil:
|
|
|
|
return // already set, don't apply defaults.
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.BootstrapNodesV5 = make([]*discv5.Node, 0, len(urls))
|
|
|
|
for _, url := range urls {
|
|
|
|
node, err := discv5.ParseNode(url)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Bootstrap URL invalid", "enode", url, "err", err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
cfg.BootstrapNodesV5 = append(cfg.BootstrapNodesV5, node)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// setListenAddress creates a TCP listening address string from set command
|
2015-11-17 08:33:25 -08:00
|
|
|
// line flags.
|
2017-10-31 15:24:11 -07:00
|
|
|
func setListenAddress(ctx *cli.Context, cfg *p2p.Config) {
|
|
|
|
if ctx.GlobalIsSet(ListenPortFlag.Name) {
|
|
|
|
cfg.ListenAddr = fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name))
|
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setNAT creates a port mapper from command line flags.
|
|
|
|
func setNAT(ctx *cli.Context, cfg *p2p.Config) {
|
|
|
|
if ctx.GlobalIsSet(NATFlag.Name) {
|
|
|
|
natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Option %s: %v", NATFlag.Name, err)
|
|
|
|
}
|
|
|
|
cfg.NAT = natif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// splitAndTrim splits input separated by a comma
|
|
|
|
// and trims excessive white space from the substrings.
|
|
|
|
func splitAndTrim(input string) []string {
|
2016-04-14 07:18:35 -07:00
|
|
|
result := strings.Split(input, ",")
|
|
|
|
for i, r := range result {
|
|
|
|
result[i] = strings.TrimSpace(r)
|
|
|
|
}
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setHTTP creates the HTTP RPC listener interface string from the set
|
2016-02-05 03:45:36 -08:00
|
|
|
// command line flags, returning empty if the HTTP endpoint is disabled.
|
2017-10-31 15:24:11 -07:00
|
|
|
func setHTTP(ctx *cli.Context, cfg *node.Config) {
|
|
|
|
if ctx.GlobalBool(RPCEnabledFlag.Name) && cfg.HTTPHost == "" {
|
|
|
|
cfg.HTTPHost = "127.0.0.1"
|
|
|
|
if ctx.GlobalIsSet(RPCListenAddrFlag.Name) {
|
|
|
|
cfg.HTTPHost = ctx.GlobalString(RPCListenAddrFlag.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.GlobalIsSet(RPCPortFlag.Name) {
|
|
|
|
cfg.HTTPPort = ctx.GlobalInt(RPCPortFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(RPCCORSDomainFlag.Name) {
|
|
|
|
cfg.HTTPCors = splitAndTrim(ctx.GlobalString(RPCCORSDomainFlag.Name))
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(RPCApiFlag.Name) {
|
|
|
|
cfg.HTTPModules = splitAndTrim(ctx.GlobalString(RPCApiFlag.Name))
|
2016-02-05 03:45:36 -08:00
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
if ctx.GlobalIsSet(RPCVirtualHostsFlag.Name) {
|
|
|
|
cfg.HTTPVirtualHosts = splitAndTrim(ctx.GlobalString(RPCVirtualHostsFlag.Name))
|
|
|
|
}
|
2016-02-05 03:45:36 -08:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setWS creates the WebSocket RPC listener interface string from the set
|
2016-02-05 05:08:48 -08:00
|
|
|
// command line flags, returning empty if the HTTP endpoint is disabled.
|
2017-10-31 15:24:11 -07:00
|
|
|
func setWS(ctx *cli.Context, cfg *node.Config) {
|
|
|
|
if ctx.GlobalBool(WSEnabledFlag.Name) && cfg.WSHost == "" {
|
|
|
|
cfg.WSHost = "127.0.0.1"
|
|
|
|
if ctx.GlobalIsSet(WSListenAddrFlag.Name) {
|
|
|
|
cfg.WSHost = ctx.GlobalString(WSListenAddrFlag.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.GlobalIsSet(WSPortFlag.Name) {
|
|
|
|
cfg.WSPort = ctx.GlobalInt(WSPortFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(WSAllowedOriginsFlag.Name) {
|
|
|
|
cfg.WSOrigins = splitAndTrim(ctx.GlobalString(WSAllowedOriginsFlag.Name))
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(WSApiFlag.Name) {
|
|
|
|
cfg.WSModules = splitAndTrim(ctx.GlobalString(WSApiFlag.Name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// setIPC creates an IPC path configuration from the set command line flags,
|
|
|
|
// returning an empty string if IPC was explicitly disabled, or the set path.
|
|
|
|
func setIPC(ctx *cli.Context, cfg *node.Config) {
|
|
|
|
checkExclusive(ctx, IPCDisabledFlag, IPCPathFlag)
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalBool(IPCDisabledFlag.Name):
|
|
|
|
cfg.IPCPath = ""
|
|
|
|
case ctx.GlobalIsSet(IPCPathFlag.Name):
|
|
|
|
cfg.IPCPath = ctx.GlobalString(IPCPathFlag.Name)
|
2016-02-05 05:08:48 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// makeDatabaseHandles raises out the number of allowed file handles per process
|
2016-02-19 04:29:19 -08:00
|
|
|
// for Geth and returns half of the allowance to assign to the database.
|
2017-10-31 15:24:11 -07:00
|
|
|
func makeDatabaseHandles() int {
|
2018-12-13 08:32:48 -08:00
|
|
|
limit, err := fdlimit.Maximum()
|
2016-02-19 04:29:19 -08:00
|
|
|
if err != nil {
|
|
|
|
Fatalf("Failed to retrieve file descriptor allowance: %v", err)
|
|
|
|
}
|
2018-12-13 08:32:48 -08:00
|
|
|
if err := fdlimit.Raise(uint64(limit)); err != nil {
|
|
|
|
Fatalf("Failed to raise file descriptor allowance: %v", err)
|
2016-02-19 04:29:19 -08:00
|
|
|
}
|
|
|
|
return limit / 2 // Leave half for networking and other stuff
|
|
|
|
}
|
|
|
|
|
2015-11-17 08:33:25 -08:00
|
|
|
// MakeAddress converts an account specified directly as a hex encoded string or
|
|
|
|
// a key index in the key store to an internal account representation.
|
2017-10-31 15:24:11 -07:00
|
|
|
func MakeAddress(ks *keystore.KeyStore, account string) (accounts.Account, error) {
|
2015-11-17 08:33:25 -08:00
|
|
|
// If the specified account is a valid address, return it
|
|
|
|
if common.IsHexAddress(account) {
|
2016-03-02 16:09:16 -08:00
|
|
|
return accounts.Account{Address: common.HexToAddress(account)}, nil
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
// Otherwise try to interpret the account as a keystore index
|
|
|
|
index, err := strconv.Atoi(account)
|
2017-10-31 15:24:11 -07:00
|
|
|
if err != nil || index < 0 {
|
2016-03-02 16:09:16 -08:00
|
|
|
return accounts.Account{}, fmt.Errorf("invalid account address or index %q", account)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
log.Warn("-------------------------------------------------------------------")
|
|
|
|
log.Warn("Referring to accounts by order in the keystore folder is dangerous!")
|
|
|
|
log.Warn("This functionality is deprecated and will be removed in the future!")
|
|
|
|
log.Warn("Please use explicit addresses! (can search via `geth account list`)")
|
|
|
|
log.Warn("-------------------------------------------------------------------")
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
accs := ks.Accounts()
|
|
|
|
if len(accs) <= index {
|
|
|
|
return accounts.Account{}, fmt.Errorf("index %d higher than number of accounts %d", index, len(accs))
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
return accs[index], nil
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// setEtherbase retrieves the etherbase either from the directly specified
|
|
|
|
// command line flags or from the keystore if CLI indexed.
|
|
|
|
func setEtherbase(ctx *cli.Context, ks *keystore.KeyStore, cfg *eth.Config) {
|
2018-08-15 01:01:49 -07:00
|
|
|
// Extract the current etherbase, new flag overriding legacy one
|
|
|
|
var etherbase string
|
|
|
|
if ctx.GlobalIsSet(MinerLegacyEtherbaseFlag.Name) {
|
|
|
|
etherbase = ctx.GlobalString(MinerLegacyEtherbaseFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(MinerEtherbaseFlag.Name) {
|
|
|
|
etherbase = ctx.GlobalString(MinerEtherbaseFlag.Name)
|
|
|
|
}
|
|
|
|
// Convert the etherbase into an address and configure it
|
|
|
|
if etherbase != "" {
|
|
|
|
account, err := MakeAddress(ks, etherbase)
|
2017-10-31 15:24:11 -07:00
|
|
|
if err != nil {
|
2018-08-15 01:01:49 -07:00
|
|
|
Fatalf("Invalid miner etherbase: %v", err)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
cfg.Etherbase = account.Address
|
2015-07-07 03:53:36 -07:00
|
|
|
}
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// MakePasswordList reads password lines from the file specified by the global --password flag.
|
2015-11-17 08:33:25 -08:00
|
|
|
func MakePasswordList(ctx *cli.Context) []string {
|
2016-03-30 14:20:06 -07:00
|
|
|
path := ctx.GlobalString(PasswordFileFlag.Name)
|
|
|
|
if path == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
text, err := ioutil.ReadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Failed to read password file: %v", err)
|
|
|
|
}
|
|
|
|
lines := strings.Split(string(text), "\n")
|
|
|
|
// Sanitise DOS line endings.
|
|
|
|
for i := range lines {
|
|
|
|
lines[i] = strings.TrimRight(lines[i], "\r")
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2016-03-30 14:20:06 -07:00
|
|
|
return lines
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
|
|
|
|
setNodeKey(ctx, cfg)
|
|
|
|
setNAT(ctx, cfg)
|
|
|
|
setListenAddress(ctx, cfg)
|
|
|
|
setBootstrapNodes(ctx, cfg)
|
|
|
|
setBootstrapNodesV5(ctx, cfg)
|
|
|
|
|
2018-08-15 01:01:49 -07:00
|
|
|
lightClient := ctx.GlobalString(SyncModeFlag.Name) == "light"
|
2018-05-23 22:32:26 -07:00
|
|
|
lightServer := ctx.GlobalInt(LightServFlag.Name) != 0
|
|
|
|
lightPeers := ctx.GlobalInt(LightPeersFlag.Name)
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalIsSet(MaxPeersFlag.Name) {
|
|
|
|
cfg.MaxPeers = ctx.GlobalInt(MaxPeersFlag.Name)
|
2018-05-23 22:32:26 -07:00
|
|
|
if lightServer && !ctx.GlobalIsSet(LightPeersFlag.Name) {
|
|
|
|
cfg.MaxPeers += lightPeers
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if lightServer {
|
|
|
|
cfg.MaxPeers += lightPeers
|
|
|
|
}
|
|
|
|
if lightClient && ctx.GlobalIsSet(LightPeersFlag.Name) && cfg.MaxPeers < lightPeers {
|
|
|
|
cfg.MaxPeers = lightPeers
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !(lightClient || lightServer) {
|
|
|
|
lightPeers = 0
|
|
|
|
}
|
|
|
|
ethPeers := cfg.MaxPeers - lightPeers
|
|
|
|
if lightClient {
|
|
|
|
ethPeers = 0
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
log.Info("Maximum peer count", "ETH", ethPeers, "LES", lightPeers, "total", cfg.MaxPeers)
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalIsSet(MaxPendingPeersFlag.Name) {
|
|
|
|
cfg.MaxPendingPeers = ctx.GlobalInt(MaxPendingPeersFlag.Name)
|
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
if ctx.GlobalIsSet(NoDiscoverFlag.Name) || lightClient {
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.NoDiscovery = true
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
|
|
|
|
// if we're running a light client or server, force enable the v5 peer discovery
|
|
|
|
// unless it is explicitly disabled with --nodiscover note that explicitly specifying
|
|
|
|
// --v5disc overrides --nodiscover, in which case the later only disables v4 discovery
|
2018-05-23 22:32:26 -07:00
|
|
|
forceV5Discovery := (lightClient || lightServer) && !ctx.GlobalBool(NoDiscoverFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalIsSet(DiscoveryV5Flag.Name) {
|
|
|
|
cfg.DiscoveryV5 = ctx.GlobalBool(DiscoveryV5Flag.Name)
|
|
|
|
} else if forceV5Discovery {
|
|
|
|
cfg.DiscoveryV5 = true
|
|
|
|
}
|
|
|
|
|
|
|
|
if netrestrict := ctx.GlobalString(NetrestrictFlag.Name); netrestrict != "" {
|
|
|
|
list, err := netutil.ParseNetlist(netrestrict)
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Option %q: %v", NetrestrictFlag.Name, err)
|
|
|
|
}
|
|
|
|
cfg.NetRestrict = list
|
|
|
|
}
|
|
|
|
|
2018-05-23 22:32:26 -07:00
|
|
|
if ctx.GlobalBool(DeveloperFlag.Name) {
|
2017-10-31 15:24:11 -07:00
|
|
|
// --dev mode can't use p2p networking.
|
|
|
|
cfg.MaxPeers = 0
|
|
|
|
cfg.ListenAddr = ":0"
|
|
|
|
cfg.NoDiscovery = true
|
|
|
|
cfg.DiscoveryV5 = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetNodeConfig applies node-related command line flags to the config.
|
|
|
|
func SetNodeConfig(ctx *cli.Context, cfg *node.Config) {
|
|
|
|
SetP2PConfig(ctx, &cfg.P2P)
|
|
|
|
setIPC(ctx, cfg)
|
|
|
|
setHTTP(ctx, cfg)
|
|
|
|
setWS(ctx, cfg)
|
|
|
|
setNodeUserIdent(ctx, cfg)
|
|
|
|
|
|
|
|
cfg.EnableNodePermission = ctx.GlobalBool(EnableNodePermissionFlag.Name)
|
|
|
|
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalIsSet(DataDirFlag.Name):
|
|
|
|
cfg.DataDir = ctx.GlobalString(DataDirFlag.Name)
|
2018-05-23 22:32:26 -07:00
|
|
|
case ctx.GlobalBool(DeveloperFlag.Name):
|
|
|
|
cfg.DataDir = "" // unless explicitly requested, use memory databases
|
2017-10-31 15:24:11 -07:00
|
|
|
case ctx.GlobalBool(TestnetFlag.Name):
|
|
|
|
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "testnet")
|
|
|
|
case ctx.GlobalBool(RinkebyFlag.Name):
|
|
|
|
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "rinkeby")
|
|
|
|
case ctx.GlobalBool(OttomanFlag.Name):
|
|
|
|
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "ottoman")
|
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.GlobalIsSet(KeyStoreDirFlag.Name) {
|
|
|
|
cfg.KeyStoreDir = ctx.GlobalString(KeyStoreDirFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(LightKDFFlag.Name) {
|
|
|
|
cfg.UseLightweightKDF = ctx.GlobalBool(LightKDFFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(NoUSBFlag.Name) {
|
|
|
|
cfg.NoUSB = ctx.GlobalBool(NoUSBFlag.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func setGPO(ctx *cli.Context, cfg *gasprice.Config) {
|
|
|
|
if ctx.GlobalIsSet(GpoBlocksFlag.Name) {
|
|
|
|
cfg.Blocks = ctx.GlobalInt(GpoBlocksFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(GpoPercentileFlag.Name) {
|
|
|
|
cfg.Percentile = ctx.GlobalInt(GpoPercentileFlag.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func setTxPool(ctx *cli.Context, cfg *core.TxPoolConfig) {
|
2018-08-21 10:30:06 -07:00
|
|
|
if ctx.GlobalIsSet(TxPoolLocalsFlag.Name) {
|
|
|
|
locals := strings.Split(ctx.GlobalString(TxPoolLocalsFlag.Name), ",")
|
|
|
|
for _, account := range locals {
|
|
|
|
if trimmed := strings.TrimSpace(account); !common.IsHexAddress(trimmed) {
|
|
|
|
Fatalf("Invalid account in --txpool.locals: %s", trimmed)
|
|
|
|
} else {
|
|
|
|
cfg.Locals = append(cfg.Locals, common.HexToAddress(account))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalIsSet(TxPoolNoLocalsFlag.Name) {
|
|
|
|
cfg.NoLocals = ctx.GlobalBool(TxPoolNoLocalsFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolJournalFlag.Name) {
|
|
|
|
cfg.Journal = ctx.GlobalString(TxPoolJournalFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolRejournalFlag.Name) {
|
|
|
|
cfg.Rejournal = ctx.GlobalDuration(TxPoolRejournalFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolPriceLimitFlag.Name) {
|
|
|
|
cfg.PriceLimit = ctx.GlobalUint64(TxPoolPriceLimitFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolPriceBumpFlag.Name) {
|
|
|
|
cfg.PriceBump = ctx.GlobalUint64(TxPoolPriceBumpFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolAccountSlotsFlag.Name) {
|
|
|
|
cfg.AccountSlots = ctx.GlobalUint64(TxPoolAccountSlotsFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolGlobalSlotsFlag.Name) {
|
|
|
|
cfg.GlobalSlots = ctx.GlobalUint64(TxPoolGlobalSlotsFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolAccountQueueFlag.Name) {
|
|
|
|
cfg.AccountQueue = ctx.GlobalUint64(TxPoolAccountQueueFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolGlobalQueueFlag.Name) {
|
|
|
|
cfg.GlobalQueue = ctx.GlobalUint64(TxPoolGlobalQueueFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(TxPoolLifetimeFlag.Name) {
|
|
|
|
cfg.Lifetime = ctx.GlobalDuration(TxPoolLifetimeFlag.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func setEthash(ctx *cli.Context, cfg *eth.Config) {
|
|
|
|
if ctx.GlobalIsSet(EthashCacheDirFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
cfg.Ethash.CacheDir = ctx.GlobalString(EthashCacheDirFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(EthashDatasetDirFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
cfg.Ethash.DatasetDir = ctx.GlobalString(EthashDatasetDirFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(EthashCachesInMemoryFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
cfg.Ethash.CachesInMem = ctx.GlobalInt(EthashCachesInMemoryFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(EthashCachesOnDiskFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
cfg.Ethash.CachesOnDisk = ctx.GlobalInt(EthashCachesOnDiskFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(EthashDatasetsInMemoryFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
cfg.Ethash.DatasetsInMem = ctx.GlobalInt(EthashDatasetsInMemoryFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(EthashDatasetsOnDiskFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
cfg.Ethash.DatasetsOnDisk = ctx.GlobalInt(EthashDatasetsOnDiskFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func setIstanbul(ctx *cli.Context, cfg *eth.Config) {
|
|
|
|
if ctx.GlobalIsSet(IstanbulRequestTimeoutFlag.Name) {
|
|
|
|
cfg.Istanbul.RequestTimeout = ctx.GlobalUint64(IstanbulRequestTimeoutFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(IstanbulBlockPeriodFlag.Name) {
|
|
|
|
cfg.Istanbul.BlockPeriod = ctx.GlobalUint64(IstanbulBlockPeriodFlag.Name)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-09 07:34:59 -07:00
|
|
|
// checkExclusive verifies that only a single instance of the provided flags was
|
2017-11-24 07:07:22 -08:00
|
|
|
// set by the user. Each flag might optionally be followed by a string type to
|
|
|
|
// specialize it further.
|
2018-05-23 22:32:26 -07:00
|
|
|
func checkExclusive(ctx *cli.Context, args ...interface{}) {
|
2017-10-31 15:24:11 -07:00
|
|
|
set := make([]string, 0, 1)
|
2018-05-23 22:32:26 -07:00
|
|
|
for i := 0; i < len(args); i++ {
|
|
|
|
// Make sure the next argument is a flag and skip if not set
|
|
|
|
flag, ok := args[i].(cli.Flag)
|
|
|
|
if !ok {
|
|
|
|
panic(fmt.Sprintf("invalid argument, not cli.Flag type: %T", args[i]))
|
|
|
|
}
|
|
|
|
// Check if next arg extends current and expand its name if so
|
|
|
|
name := flag.GetName()
|
|
|
|
|
|
|
|
if i+1 < len(args) {
|
|
|
|
switch option := args[i+1].(type) {
|
|
|
|
case string:
|
2018-10-08 07:08:56 -07:00
|
|
|
// Extended flag check, make sure value set doesn't conflict with passed in option
|
2018-05-23 22:32:26 -07:00
|
|
|
if ctx.GlobalString(flag.GetName()) == option {
|
|
|
|
name += "=" + option
|
2018-10-08 07:08:56 -07:00
|
|
|
set = append(set, "--"+name)
|
2018-05-23 22:32:26 -07:00
|
|
|
}
|
2018-10-08 07:08:56 -07:00
|
|
|
// shift arguments and continue
|
2018-05-23 22:32:26 -07:00
|
|
|
i++
|
2018-10-08 07:08:56 -07:00
|
|
|
continue
|
2018-05-23 22:32:26 -07:00
|
|
|
|
|
|
|
case cli.Flag:
|
|
|
|
default:
|
|
|
|
panic(fmt.Sprintf("invalid argument, not cli.Flag or string extension: %T", args[i+1]))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Mark the flag if it's set
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalIsSet(flag.GetName()) {
|
2018-05-23 22:32:26 -07:00
|
|
|
set = append(set, "--"+name)
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
if len(set) > 1 {
|
2018-05-23 22:32:26 -07:00
|
|
|
Fatalf("Flags %v can't be used at the same time", strings.Join(set, ", "))
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// SetShhConfig applies shh-related command line flags to the config.
|
|
|
|
func SetShhConfig(ctx *cli.Context, stack *node.Node, cfg *whisper.Config) {
|
|
|
|
if ctx.GlobalIsSet(WhisperMaxMessageSizeFlag.Name) {
|
|
|
|
cfg.MaxMessageSize = uint32(ctx.GlobalUint(WhisperMaxMessageSizeFlag.Name))
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(WhisperMinPOWFlag.Name) {
|
|
|
|
cfg.MinimumAcceptedPOW = ctx.GlobalFloat64(WhisperMinPOWFlag.Name)
|
|
|
|
}
|
2018-09-05 01:57:45 -07:00
|
|
|
if ctx.GlobalIsSet(WhisperRestrictConnectionBetweenLightClientsFlag.Name) {
|
|
|
|
cfg.RestrictConnectionBetweenLightClients = true
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// SetEthConfig applies eth-related command line flags to the config.
|
|
|
|
func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
|
2015-11-17 08:33:25 -08:00
|
|
|
// Avoid conflicting network flags
|
2017-10-24 03:40:42 -07:00
|
|
|
checkExclusive(ctx, DeveloperFlag, TestnetFlag, RinkebyFlag)
|
2018-05-23 22:32:26 -07:00
|
|
|
checkExclusive(ctx, LightServFlag, SyncModeFlag, "light")
|
2017-10-31 15:24:11 -07:00
|
|
|
|
|
|
|
ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
|
|
|
|
setEtherbase(ctx, ks, cfg)
|
|
|
|
setGPO(ctx, &cfg.GPO)
|
|
|
|
setTxPool(ctx, &cfg.TxPool)
|
|
|
|
setEthash(ctx, cfg)
|
|
|
|
setIstanbul(ctx, cfg)
|
|
|
|
|
2018-08-15 01:01:49 -07:00
|
|
|
if ctx.GlobalIsSet(SyncModeFlag.Name) {
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.SyncMode = *GlobalTextMarshaler(ctx, SyncModeFlag.Name).(*downloader.SyncMode)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(LightServFlag.Name) {
|
|
|
|
cfg.LightServ = ctx.GlobalInt(LightServFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(LightPeersFlag.Name) {
|
|
|
|
cfg.LightPeers = ctx.GlobalInt(LightPeersFlag.Name)
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
if ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
|
|
|
cfg.NetworkId = ctx.GlobalUint64(NetworkIdFlag.Name)
|
|
|
|
}
|
|
|
|
|
2018-05-23 22:32:26 -07:00
|
|
|
if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheDatabaseFlag.Name) {
|
|
|
|
cfg.DatabaseCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheDatabaseFlag.Name) / 100
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
cfg.DatabaseHandles = makeDatabaseHandles()
|
|
|
|
|
2018-05-23 22:32:26 -07:00
|
|
|
if gcmode := ctx.GlobalString(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
|
|
|
|
Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)
|
|
|
|
}
|
|
|
|
cfg.NoPruning = ctx.GlobalString(GCModeFlag.Name) == "archive"
|
|
|
|
|
|
|
|
if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
|
|
|
|
cfg.TrieCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
|
|
|
|
}
|
2018-08-08 02:15:08 -07:00
|
|
|
if ctx.GlobalIsSet(MinerNotifyFlag.Name) {
|
|
|
|
cfg.MinerNotify = strings.Split(ctx.GlobalString(MinerNotifyFlag.Name), ",")
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(DocRootFlag.Name) {
|
|
|
|
cfg.DocRoot = ctx.GlobalString(DocRootFlag.Name)
|
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
if ctx.GlobalIsSet(MinerLegacyExtraDataFlag.Name) {
|
2018-08-21 12:56:54 -07:00
|
|
|
cfg.MinerExtraData = []byte(ctx.GlobalString(MinerLegacyExtraDataFlag.Name))
|
2017-04-12 07:27:23 -07:00
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
if ctx.GlobalIsSet(MinerExtraDataFlag.Name) {
|
2018-08-21 12:56:54 -07:00
|
|
|
cfg.MinerExtraData = []byte(ctx.GlobalString(MinerExtraDataFlag.Name))
|
2018-08-15 01:01:49 -07:00
|
|
|
}
|
2018-08-29 02:21:12 -07:00
|
|
|
if ctx.GlobalIsSet(MinerLegacyGasTargetFlag.Name) {
|
|
|
|
cfg.MinerGasFloor = ctx.GlobalUint64(MinerLegacyGasTargetFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2018-08-29 02:21:12 -07:00
|
|
|
if ctx.GlobalIsSet(MinerGasTargetFlag.Name) {
|
|
|
|
cfg.MinerGasFloor = ctx.GlobalUint64(MinerGasTargetFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(MinerGasLimitFlag.Name) {
|
|
|
|
cfg.MinerGasCeil = ctx.GlobalUint64(MinerGasLimitFlag.Name)
|
|
|
|
}
|
2018-08-15 01:01:49 -07:00
|
|
|
if ctx.GlobalIsSet(MinerLegacyGasPriceFlag.Name) {
|
2018-08-21 12:56:54 -07:00
|
|
|
cfg.MinerGasPrice = GlobalBig(ctx, MinerLegacyGasPriceFlag.Name)
|
2018-08-15 01:01:49 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(MinerGasPriceFlag.Name) {
|
2018-08-21 12:56:54 -07:00
|
|
|
cfg.MinerGasPrice = GlobalBig(ctx, MinerGasPriceFlag.Name)
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(MinerRecommitIntervalFlag.Name) {
|
|
|
|
cfg.MinerRecommit = ctx.Duration(MinerRecommitIntervalFlag.Name)
|
2017-04-12 07:27:23 -07:00
|
|
|
}
|
2018-08-28 06:59:05 -07:00
|
|
|
if ctx.GlobalIsSet(MinerNoVerfiyFlag.Name) {
|
|
|
|
cfg.MinerNoverify = ctx.Bool(MinerNoVerfiyFlag.Name)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(VMEnableDebugFlag.Name) {
|
|
|
|
// TODO(fjl): force-enable this in --dev mode
|
|
|
|
cfg.EnablePreimageRecording = ctx.GlobalBool(VMEnableDebugFlag.Name)
|
|
|
|
}
|
|
|
|
|
2018-09-20 00:44:35 -07:00
|
|
|
if ctx.GlobalIsSet(EWASMInterpreterFlag.Name) {
|
|
|
|
cfg.EWASMInterpreter = ctx.GlobalString(EWASMInterpreterFlag.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.GlobalIsSet(EVMInterpreterFlag.Name) {
|
|
|
|
cfg.EVMInterpreter = ctx.GlobalString(EVMInterpreterFlag.Name)
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// Override any default configs for hard coded networks.
|
2015-11-17 08:33:25 -08:00
|
|
|
switch {
|
2017-10-31 15:24:11 -07:00
|
|
|
case ctx.GlobalBool(TestnetFlag.Name):
|
2015-11-17 08:33:25 -08:00
|
|
|
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.NetworkId = 3
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.Genesis = core.DefaultTestnetGenesisBlock()
|
|
|
|
case ctx.GlobalBool(RinkebyFlag.Name):
|
2015-11-17 08:33:25 -08:00
|
|
|
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.NetworkId = 4
|
2015-11-17 08:33:25 -08:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.Genesis = core.DefaultRinkebyGenesisBlock()
|
|
|
|
case ctx.GlobalBool(OttomanFlag.Name):
|
|
|
|
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
|
|
|
cfg.NetworkId = 5
|
2018-05-29 06:05:18 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
cfg.Genesis = core.DefaultOttomanGenesisBlock()
|
2018-05-23 22:32:26 -07:00
|
|
|
case ctx.GlobalBool(DeveloperFlag.Name):
|
2018-06-14 02:31:31 -07:00
|
|
|
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
|
|
|
|
cfg.NetworkId = 1337
|
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
// Create new developer account or reuse existing one
|
|
|
|
var (
|
|
|
|
developer accounts.Account
|
|
|
|
err error
|
|
|
|
)
|
|
|
|
if accs := ks.Accounts(); len(accs) > 0 {
|
|
|
|
developer = ks.Accounts()[0]
|
|
|
|
} else {
|
|
|
|
developer, err = ks.NewAccount("")
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("Failed to create developer account: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if err := ks.Unlock(developer, ""); err != nil {
|
|
|
|
Fatalf("Failed to unlock developer account: %v", err)
|
|
|
|
}
|
|
|
|
log.Info("Using developer account", "address", developer.Address)
|
|
|
|
|
|
|
|
cfg.Genesis = core.DeveloperGenesisBlock(uint64(ctx.GlobalInt(DeveloperPeriodFlag.Name)), developer.Address)
|
2018-08-15 01:01:49 -07:00
|
|
|
if !ctx.GlobalIsSet(MinerGasPriceFlag.Name) && !ctx.GlobalIsSet(MinerLegacyGasPriceFlag.Name) {
|
2018-08-21 12:56:54 -07:00
|
|
|
cfg.MinerGasPrice = big.NewInt(1)
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2015-09-06 06:46:54 -07:00
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
// TODO(fjl): move trie cache generations into config
|
2016-10-19 04:55:13 -07:00
|
|
|
if gen := ctx.GlobalInt(TrieCacheGenFlag.Name); gen > 0 {
|
|
|
|
state.MaxTrieCacheGen = uint16(gen)
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
2015-12-15 19:26:23 -08:00
|
|
|
|
2018-05-23 22:32:26 -07:00
|
|
|
// SetDashboardConfig applies dashboard related command line flags to the config.
|
|
|
|
func SetDashboardConfig(ctx *cli.Context, cfg *dashboard.Config) {
|
|
|
|
cfg.Host = ctx.GlobalString(DashboardAddrFlag.Name)
|
|
|
|
cfg.Port = ctx.GlobalInt(DashboardPortFlag.Name)
|
|
|
|
cfg.Refresh = ctx.GlobalDuration(DashboardRefreshFlag.Name)
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// RegisterEthService adds an Ethereum client to the stack.
|
2018-07-24 01:15:38 -07:00
|
|
|
func RegisterEthService(stack *node.Node, cfg *eth.Config) <-chan *eth.Ethereum {
|
|
|
|
nodeChan := make(chan *eth.Ethereum, 1)
|
2017-10-31 15:24:11 -07:00
|
|
|
var err error
|
|
|
|
if cfg.SyncMode == downloader.LightSync {
|
|
|
|
err = stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
return les.New(ctx, cfg)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
err = stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
fullNode, err := eth.New(ctx, cfg)
|
|
|
|
if fullNode != nil && cfg.LightServ > 0 {
|
|
|
|
ls, _ := les.NewLesServer(fullNode, cfg)
|
|
|
|
fullNode.AddLesServer(ls)
|
|
|
|
}
|
2018-07-24 01:15:38 -07:00
|
|
|
nodeChan <- fullNode
|
2017-10-31 15:24:11 -07:00
|
|
|
return fullNode, err
|
|
|
|
})
|
|
|
|
}
|
|
|
|
if err != nil {
|
2015-11-17 08:33:25 -08:00
|
|
|
Fatalf("Failed to register the Ethereum service: %v", err)
|
|
|
|
}
|
2017-03-23 11:41:02 -07:00
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
return nodeChan
|
|
|
|
}
|
2017-03-23 11:41:02 -07:00
|
|
|
|
2018-05-23 22:32:26 -07:00
|
|
|
// RegisterDashboardService adds a dashboard to the stack.
|
|
|
|
func RegisterDashboardService(stack *node.Node, cfg *dashboard.Config, commit string) {
|
|
|
|
stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
cmd, dashboard, log: log collection and exploration (#17097)
* cmd, dashboard, internal, log, node: logging feature
* cmd, dashboard, internal, log: requested changes
* dashboard, vendor: gofmt, govendor, use vendored file watcher
* dashboard, log: gofmt -s -w, goimports
* dashboard, log: gosimple
2018-07-11 00:59:04 -07:00
|
|
|
return dashboard.New(cfg, commit, ctx.ResolvePath("logs")), nil
|
2018-05-23 22:32:26 -07:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// RegisterShhService configures Whisper and adds it to the given node.
|
|
|
|
func RegisterShhService(stack *node.Node, cfg *whisper.Config) {
|
|
|
|
if err := stack.Register(func(n *node.ServiceContext) (node.Service, error) {
|
|
|
|
return whisper.New(cfg), nil
|
|
|
|
}); err != nil {
|
|
|
|
Fatalf("Failed to register the Whisper service: %v", err)
|
2017-03-23 11:41:02 -07:00
|
|
|
}
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
// RegisterEthStatsService configures the Ethereum Stats daemon and adds it to
|
2018-07-26 00:59:05 -07:00
|
|
|
// the given node.
|
2017-10-31 15:24:11 -07:00
|
|
|
func RegisterEthStatsService(stack *node.Node, url string) {
|
|
|
|
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
|
|
|
|
// Retrieve both eth and les services
|
|
|
|
var ethServ *eth.Ethereum
|
|
|
|
ctx.Service(ðServ)
|
|
|
|
|
|
|
|
var lesServ *les.LightEthereum
|
|
|
|
ctx.Service(&lesServ)
|
|
|
|
|
|
|
|
return ethstats.New(url, ethServ, lesServ)
|
|
|
|
}); err != nil {
|
|
|
|
Fatalf("Failed to register the Ethereum Stats service: %v", err)
|
2016-08-15 09:38:32 -07:00
|
|
|
}
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
|
|
|
|
2018-07-02 05:51:02 -07:00
|
|
|
func SetupMetrics(ctx *cli.Context) {
|
|
|
|
if metrics.Enabled {
|
|
|
|
log.Info("Enabling metrics collection")
|
|
|
|
var (
|
|
|
|
enableExport = ctx.GlobalBool(MetricsEnableInfluxDBFlag.Name)
|
|
|
|
endpoint = ctx.GlobalString(MetricsInfluxDBEndpointFlag.Name)
|
|
|
|
database = ctx.GlobalString(MetricsInfluxDBDatabaseFlag.Name)
|
|
|
|
username = ctx.GlobalString(MetricsInfluxDBUsernameFlag.Name)
|
|
|
|
password = ctx.GlobalString(MetricsInfluxDBPasswordFlag.Name)
|
|
|
|
hosttag = ctx.GlobalString(MetricsInfluxDBHostTagFlag.Name)
|
|
|
|
)
|
|
|
|
|
|
|
|
if enableExport {
|
|
|
|
log.Info("Enabling metrics export to InfluxDB")
|
|
|
|
go influxdb.InfluxDBWithTags(metrics.DefaultRegistry, 10*time.Second, endpoint, database, username, password, "geth.", map[string]string{
|
|
|
|
"host": hosttag,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 14:32:43 -08:00
|
|
|
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
|
2016-08-18 04:28:17 -07:00
|
|
|
func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database {
|
2016-03-01 14:32:43 -08:00
|
|
|
var (
|
2018-05-23 22:32:26 -07:00
|
|
|
cache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheDatabaseFlag.Name) / 100
|
2017-10-31 15:24:11 -07:00
|
|
|
handles = makeDatabaseHandles()
|
2016-03-01 14:32:43 -08:00
|
|
|
)
|
2017-10-31 15:24:11 -07:00
|
|
|
name := "chaindata"
|
2018-08-15 01:01:49 -07:00
|
|
|
if ctx.GlobalString(SyncModeFlag.Name) == "light" {
|
2017-10-31 15:24:11 -07:00
|
|
|
name = "lightchaindata"
|
|
|
|
}
|
|
|
|
chainDb, err := stack.OpenDatabase(name, cache, handles)
|
2016-03-01 14:32:43 -08:00
|
|
|
if err != nil {
|
2015-04-13 01:13:52 -07:00
|
|
|
Fatalf("Could not open database: %v", err)
|
|
|
|
}
|
2016-03-01 14:32:43 -08:00
|
|
|
return chainDb
|
|
|
|
}
|
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
func MakeGenesis(ctx *cli.Context) *core.Genesis {
|
|
|
|
var genesis *core.Genesis
|
|
|
|
switch {
|
|
|
|
case ctx.GlobalBool(TestnetFlag.Name):
|
|
|
|
genesis = core.DefaultTestnetGenesisBlock()
|
|
|
|
case ctx.GlobalBool(RinkebyFlag.Name):
|
|
|
|
genesis = core.DefaultRinkebyGenesisBlock()
|
|
|
|
case ctx.GlobalBool(OttomanFlag.Name):
|
|
|
|
genesis = core.DefaultOttomanGenesisBlock()
|
2018-05-23 22:32:26 -07:00
|
|
|
case ctx.GlobalBool(DeveloperFlag.Name):
|
|
|
|
Fatalf("Developer chains are ephemeral")
|
2017-10-31 15:24:11 -07:00
|
|
|
}
|
|
|
|
return genesis
|
|
|
|
}
|
|
|
|
|
2016-03-01 14:32:43 -08:00
|
|
|
// MakeChain creates a chain manager from set command line flags.
|
2016-08-18 04:28:17 -07:00
|
|
|
func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chainDb ethdb.Database) {
|
2016-03-01 14:32:43 -08:00
|
|
|
var err error
|
2016-08-18 04:28:17 -07:00
|
|
|
chainDb = MakeChainDatabase(ctx, stack)
|
2016-03-01 14:32:43 -08:00
|
|
|
|
2017-10-31 15:24:11 -07:00
|
|
|
config, _, err := core.SetupGenesisBlock(chainDb, MakeGenesis(ctx))
|
|
|
|
if err != nil {
|
|
|
|
Fatalf("%v", err)
|
|
|
|
}
|
|
|
|
var engine consensus.Engine
|
|
|
|
if config.Clique != nil {
|
|
|
|
engine = clique.New(config.Clique, chainDb)
|
|
|
|
} else {
|
|
|
|
engine = ethash.NewFaker()
|
|
|
|
if !ctx.GlobalBool(FakePoWFlag.Name) {
|
2018-05-23 22:32:26 -07:00
|
|
|
engine = ethash.New(ethash.Config{
|
|
|
|
CacheDir: stack.ResolvePath(eth.DefaultConfig.Ethash.CacheDir),
|
|
|
|
CachesInMem: eth.DefaultConfig.Ethash.CachesInMem,
|
|
|
|
CachesOnDisk: eth.DefaultConfig.Ethash.CachesOnDisk,
|
|
|
|
DatasetDir: stack.ResolvePath(eth.DefaultConfig.Ethash.DatasetDir),
|
|
|
|
DatasetsInMem: eth.DefaultConfig.Ethash.DatasetsInMem,
|
|
|
|
DatasetsOnDisk: eth.DefaultConfig.Ethash.DatasetsOnDisk,
|
2018-08-28 06:59:05 -07:00
|
|
|
}, nil, false)
|
2015-08-03 08:48:24 -07:00
|
|
|
}
|
|
|
|
}
|
2018-05-23 22:32:26 -07:00
|
|
|
if gcmode := ctx.GlobalString(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
|
|
|
|
Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)
|
|
|
|
}
|
|
|
|
cache := &core.CacheConfig{
|
|
|
|
Disabled: ctx.GlobalString(GCModeFlag.Name) == "archive",
|
|
|
|
TrieNodeLimit: eth.DefaultConfig.TrieCache,
|
|
|
|
TrieTimeLimit: eth.DefaultConfig.TrieTimeout,
|
|
|
|
}
|
|
|
|
if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
|
|
|
|
cache.TrieNodeLimit = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
vmcfg := vm.Config{EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name)}
|
2018-09-20 05:09:30 -07:00
|
|
|
chain, err = core.NewBlockChain(chainDb, cache, config, engine, vmcfg, nil)
|
2015-06-08 03:12:13 -07:00
|
|
|
if err != nil {
|
2017-10-31 15:24:11 -07:00
|
|
|
Fatalf("Can't create BlockChain: %v", err)
|
2015-06-08 03:12:13 -07:00
|
|
|
}
|
2015-08-06 10:57:39 -07:00
|
|
|
return chain, chainDb
|
2015-03-05 18:00:41 -08:00
|
|
|
}
|
2016-05-06 02:40:23 -07:00
|
|
|
|
|
|
|
// MakeConsolePreloads retrieves the absolute paths for the console JavaScript
|
|
|
|
// scripts to preload before starting.
|
|
|
|
func MakeConsolePreloads(ctx *cli.Context) []string {
|
|
|
|
// Skip preloading if there's nothing to preload
|
|
|
|
if ctx.GlobalString(PreloadJSFlag.Name) == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
// Otherwise resolve absolute paths and return them
|
|
|
|
preloads := []string{}
|
|
|
|
|
|
|
|
assets := ctx.GlobalString(JSpathFlag.Name)
|
|
|
|
for _, file := range strings.Split(ctx.GlobalString(PreloadJSFlag.Name), ",") {
|
|
|
|
preloads = append(preloads, common.AbsolutePath(assets, strings.TrimSpace(file)))
|
|
|
|
}
|
|
|
|
return preloads
|
|
|
|
}
|
2017-10-31 15:24:11 -07:00
|
|
|
|
|
|
|
// MigrateFlags sets the global flag from a local flag when it's set.
|
|
|
|
// This is a temporary function used for migrating old command/flags to the
|
|
|
|
// new format.
|
|
|
|
//
|
|
|
|
// e.g. geth account new --keystore /tmp/mykeystore --lightkdf
|
|
|
|
//
|
|
|
|
// is equivalent after calling this method with:
|
|
|
|
//
|
|
|
|
// geth --keystore /tmp/mykeystore --lightkdf account new
|
|
|
|
//
|
|
|
|
// This allows the use of the existing configuration functionality.
|
|
|
|
// When all flags are migrated this function can be removed and the existing
|
|
|
|
// configuration functionality must be changed that is uses local flags
|
|
|
|
func MigrateFlags(action func(ctx *cli.Context) error) func(*cli.Context) error {
|
|
|
|
return func(ctx *cli.Context) error {
|
|
|
|
for _, name := range ctx.FlagNames() {
|
|
|
|
if ctx.IsSet(name) {
|
|
|
|
ctx.GlobalSet(name, ctx.String(name))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return action(ctx)
|
|
|
|
}
|
|
|
|
}
|