flags.go 48.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
// 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
11
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 13 14
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
15
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
16

17
// Package utils contains internal helper functions for go-ethereum commands.
18 19 20 21
package utils

import (
	"crypto/ecdsa"
22
	"fmt"
23
	"io/ioutil"
24
	"math/big"
25
	"os"
26
	"path/filepath"
27
	"strconv"
28
	"strings"
29
	"time"
30

31
	"github.com/ethereum/go-ethereum/accounts"
32
	"github.com/ethereum/go-ethereum/accounts/keystore"
zelig's avatar
zelig committed
33
	"github.com/ethereum/go-ethereum/common"
34
	"github.com/ethereum/go-ethereum/common/fdlimit"
35 36
	"github.com/ethereum/go-ethereum/consensus"
	"github.com/ethereum/go-ethereum/consensus/clique"
37
	"github.com/ethereum/go-ethereum/consensus/ethash"
38
	"github.com/ethereum/go-ethereum/core"
39
	"github.com/ethereum/go-ethereum/core/state"
40
	"github.com/ethereum/go-ethereum/core/vm"
41
	"github.com/ethereum/go-ethereum/crypto"
42
	"github.com/ethereum/go-ethereum/dashboard"
43
	"github.com/ethereum/go-ethereum/eth"
44 45
	"github.com/ethereum/go-ethereum/eth/downloader"
	"github.com/ethereum/go-ethereum/eth/gasprice"
46
	"github.com/ethereum/go-ethereum/ethdb"
47
	"github.com/ethereum/go-ethereum/ethstats"
48
	"github.com/ethereum/go-ethereum/les"
49
	"github.com/ethereum/go-ethereum/log"
50
	"github.com/ethereum/go-ethereum/metrics"
51
	"github.com/ethereum/go-ethereum/metrics/influxdb"
52
	"github.com/ethereum/go-ethereum/node"
53
	"github.com/ethereum/go-ethereum/p2p"
54
	"github.com/ethereum/go-ethereum/p2p/discv5"
55
	"github.com/ethereum/go-ethereum/p2p/enode"
56
	"github.com/ethereum/go-ethereum/p2p/nat"
57
	"github.com/ethereum/go-ethereum/p2p/netutil"
58
	"github.com/ethereum/go-ethereum/params"
59
	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
60
	"gopkg.in/urfave/cli.v1"
61 62
)

63 64 65 66 67
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:
68
	{{range .cmd.Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
69 70 71 72 73 74 75
	{{end}}{{end}}{{if .categorizedFlags}}
{{range $idx, $categorized := .categorizedFlags}}{{$categorized.Name}} OPTIONS:
{{range $categorized.Flags}}{{"\t"}}{{.}}
{{end}}
{{end}}{{end}}`
)

76 77 78 79 80 81 82 83 84 85 86 87 88 89
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}}
`

90
	cli.CommandHelpTemplate = CommandHelpTemplate
91 92
}

Felix Lange's avatar
Felix Lange committed
93
// NewApp creates an app with sane defaults.
94
func NewApp(gitCommit, usage string) *cli.App {
Felix Lange's avatar
Felix Lange committed
95
	app := cli.NewApp()
96
	app.Name = filepath.Base(os.Args[0])
Felix Lange's avatar
Felix Lange committed
97
	app.Author = ""
obscuren's avatar
obscuren committed
98
	//app.Authors = nil
Felix Lange's avatar
Felix Lange committed
99
	app.Email = ""
100
	app.Version = params.VersionWithMeta
101
	if len(gitCommit) >= 8 {
102 103
		app.Version += "-" + gitCommit[:8]
	}
Felix Lange's avatar
Felix Lange committed
104 105 106 107
	app.Usage = usage
	return app
}

108 109 110 111 112 113 114 115 116
// 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
117
	DataDirFlag = DirectoryFlag{
118
		Name:  "datadir",
119
		Usage: "Data directory for the databases and keystore",
120
		Value: DirectoryString{node.DefaultDataDir()},
121
	}
122 123 124 125
	KeyStoreDirFlag = DirectoryFlag{
		Name:  "keystore",
		Usage: "Directory for the keystore (default = inside the datadir)",
	}
126 127
	NoUSBFlag = cli.BoolFlag{
		Name:  "nousb",
128
		Usage: "Disables monitoring for and managing USB hardware wallets",
129
	}
130
	NetworkIdFlag = cli.Uint64Flag{
zelig's avatar
zelig committed
131
		Name:  "networkid",
132
		Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby)",
133
		Value: eth.DefaultConfig.NetworkId,
zelig's avatar
zelig committed
134
	}
135
	TestnetFlag = cli.BoolFlag{
136
		Name:  "testnet",
137
		Usage: "Ropsten network: pre-configured proof-of-work test network",
138
	}
139 140 141 142
	RinkebyFlag = cli.BoolFlag{
		Name:  "rinkeby",
		Usage: "Rinkeby network: pre-configured proof-of-authority test network",
	}
143
	DeveloperFlag = cli.BoolFlag{
144
		Name:  "dev",
145 146 147 148 149
		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)",
150
	}
151 152
	IdentityFlag = cli.StringFlag{
		Name:  "identity",
153
		Usage: "Custom node name",
154
	}
zelig's avatar
zelig committed
155 156 157
	DocRootFlag = DirectoryFlag{
		Name:  "docroot",
		Usage: "Document Root for HTTPClient file scheme",
158
		Value: DirectoryString{homeDir()},
zelig's avatar
zelig committed
159
	}
160 161 162 163 164 165
	defaultSyncMode = eth.DefaultConfig.SyncMode
	SyncModeFlag    = TextMarshalerFlag{
		Name:  "syncmode",
		Usage: `Blockchain sync mode ("fast", "full", or "light")`,
		Value: &defaultSyncMode,
	}
166 167 168 169 170
	GCModeFlag = cli.StringFlag{
		Name:  "gcmode",
		Usage: `Blockchain garbage collection mode ("full", "archive")`,
		Value: "full",
	}
171 172 173 174 175 176 177 178
	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",
179
		Value: eth.DefaultConfig.LightPeers,
180
	}
181 182
	LightKDFFlag = cli.BoolFlag{
		Name:  "lightkdf",
183
		Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
184
	}
185 186
	// Dashboard settings
	DashboardEnabledFlag = cli.BoolFlag{
187
		Name:  metrics.DashboardEnabledFlag,
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
		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,
	}
205 206 207 208 209 210 211 212
	// 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)",
213
		Value: eth.DefaultConfig.Ethash.CachesInMem,
214 215 216 217
	}
	EthashCachesOnDiskFlag = cli.IntFlag{
		Name:  "ethash.cachesondisk",
		Usage: "Number of recent ethash caches to keep on disk (16MB each)",
218
		Value: eth.DefaultConfig.Ethash.CachesOnDisk,
219 220 221 222
	}
	EthashDatasetDirFlag = DirectoryFlag{
		Name:  "ethash.dagdir",
		Usage: "Directory to store the ethash mining DAGs (default = inside home folder)",
223
		Value: DirectoryString{eth.DefaultConfig.Ethash.DatasetDir},
224 225 226 227
	}
	EthashDatasetsInMemoryFlag = cli.IntFlag{
		Name:  "ethash.dagsinmem",
		Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)",
228
		Value: eth.DefaultConfig.Ethash.DatasetsInMem,
229 230 231 232
	}
	EthashDatasetsOnDiskFlag = cli.IntFlag{
		Name:  "ethash.dagsondisk",
		Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)",
233
		Value: eth.DefaultConfig.Ethash.DatasetsOnDisk,
234 235
	}
	// Transaction pool settings
236 237 238 239
	TxPoolLocalsFlag = cli.StringFlag{
		Name:  "txpool.locals",
		Usage: "Comma separated accounts to treat as locals (no flush, priority inclusion)",
	}
240 241 242 243
	TxPoolNoLocalsFlag = cli.BoolFlag{
		Name:  "txpool.nolocals",
		Usage: "Disables price exemptions for locally submitted transactions",
	}
244 245 246 247 248 249 250 251 252 253
	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,
	}
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
	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,
	}
289 290 291
	// Performance tuning settings
	CacheFlag = cli.IntFlag{
		Name:  "cache",
292 293 294 295 296 297
		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",
298 299 300 301 302 303
		Value: 50,
	}
	CacheTrieFlag = cli.IntFlag{
		Name:  "cache.trie",
		Usage: "Percentage of cache memory allowance to use for trie caching",
		Value: 25,
304 305 306 307 308
	}
	CacheGCFlag = cli.IntFlag{
		Name:  "cache.gc",
		Usage: "Percentage of cache memory allowance to use for trie pruning",
		Value: 25,
309 310 311 312 313 314
	}
	TrieCacheGenFlag = cli.IntFlag{
		Name:  "trie-cache-gens",
		Usage: "Number of trie node generations to keep in memory",
		Value: int(state.MaxTrieCacheGen),
	}
315 316 317 318
	// Miner settings
	MiningEnabledFlag = cli.BoolFlag{
		Name:  "mine",
		Usage: "Enable mining",
319
	}
320
	MinerThreadsFlag = cli.IntFlag{
321
		Name:  "miner.threads",
322
		Usage: "Number of CPU threads to use for mining",
323 324
		Value: 0,
	}
325 326 327 328 329
	MinerLegacyThreadsFlag = cli.IntFlag{
		Name:  "minerthreads",
		Usage: "Number of CPU threads to use for mining (deprecated, use --miner.threads)",
		Value: 0,
	}
330 331 332
	MinerNotifyFlag = cli.StringFlag{
		Name:  "miner.notify",
		Usage: "Comma separated HTTP URL list to notify of new work packages",
333
	}
334 335 336
	MinerGasTargetFlag = cli.Uint64Flag{
		Name:  "miner.gastarget",
		Usage: "Target gas floor for mined blocks",
337
		Value: eth.DefaultConfig.MinerGasFloor,
338 339
	}
	MinerLegacyGasTargetFlag = cli.Uint64Flag{
340
		Name:  "targetgaslimit",
341
		Usage: "Target gas floor for mined blocks (deprecated, use --miner.gastarget)",
342 343 344 345 346 347
		Value: eth.DefaultConfig.MinerGasFloor,
	}
	MinerGasLimitFlag = cli.Uint64Flag{
		Name:  "miner.gaslimit",
		Usage: "Target gas ceiling for mined blocks",
		Value: eth.DefaultConfig.MinerGasCeil,
348
	}
349 350
	MinerGasPriceFlag = BigFlag{
		Name:  "miner.gasprice",
351
		Usage: "Minimum gas price for mining a transaction",
352
		Value: eth.DefaultConfig.MinerGasPrice,
zelig's avatar
zelig committed
353
	}
354
	MinerLegacyGasPriceFlag = BigFlag{
355
		Name:  "gasprice",
356
		Usage: "Minimum gas price for mining a transaction (deprecated, use --miner.gasprice)",
357
		Value: eth.DefaultConfig.MinerGasPrice,
358
	}
359 360 361 362 363 364 365 366 367 368 369 370
	MinerEtherbaseFlag = cli.StringFlag{
		Name:  "miner.etherbase",
		Usage: "Public address for block mining rewards (default = first account)",
		Value: "0",
	}
	MinerLegacyEtherbaseFlag = cli.StringFlag{
		Name:  "etherbase",
		Usage: "Public address for block mining rewards (default = first account, deprecated, use --miner.etherbase)",
		Value: "0",
	}
	MinerExtraDataFlag = cli.StringFlag{
		Name:  "miner.extradata",
371
		Usage: "Block extra data set by the miner (default = client version)",
zelig's avatar
zelig committed
372
	}
373 374 375 376
	MinerLegacyExtraDataFlag = cli.StringFlag{
		Name:  "extradata",
		Usage: "Block extra data set by the miner (default = client version, deprecated, use --miner.extradata)",
	}
377 378
	MinerRecommitIntervalFlag = cli.DurationFlag{
		Name:  "miner.recommit",
379
		Usage: "Time interval to recreate the block being mined",
380
		Value: eth.DefaultConfig.MinerRecommit,
381
	}
382 383 384 385
	MinerNoVerfiyFlag = cli.BoolFlag{
		Name:  "miner.noverify",
		Usage: "Disable remote sealing verification",
	}
386
	// Account settings
zelig's avatar
zelig committed
387 388
	UnlockedAccountFlag = cli.StringFlag{
		Name:  "unlock",
389
		Usage: "Comma separated list of accounts to unlock",
zelig's avatar
zelig committed
390 391 392 393
		Value: "",
	}
	PasswordFileFlag = cli.StringFlag{
		Name:  "password",
394
		Usage: "Password file to use for non-interactive password input",
zelig's avatar
zelig committed
395
		Value: "",
zelig's avatar
zelig committed
396
	}
397

398 399 400 401
	VMEnableDebugFlag = cli.BoolFlag{
		Name:  "vmdebug",
		Usage: "Record information useful for VM and contract debugging",
	}
402 403 404 405 406
	// Logging and debug settings
	EthStatsURLFlag = cli.StringFlag{
		Name:  "ethstats",
		Usage: "Reporting URL of a ethstats service (nodename:secret@host:port)",
	}
407 408 409 410
	FakePoWFlag = cli.BoolFlag{
		Name:  "fakepow",
		Usage: "Disables proof-of-work verification",
	}
411 412 413 414
	NoCompactionFlag = cli.BoolFlag{
		Name:  "nocompaction",
		Usage: "Disables db compaction after import",
	}
415 416 417
	// RPC settings
	RPCEnabledFlag = cli.BoolFlag{
		Name:  "rpc",
418
		Usage: "Enable the HTTP-RPC server",
419 420 421
	}
	RPCListenAddrFlag = cli.StringFlag{
		Name:  "rpcaddr",
422
		Usage: "HTTP-RPC server listening interface",
423
		Value: node.DefaultHTTPHost,
424 425 426
	}
	RPCPortFlag = cli.IntFlag{
		Name:  "rpcport",
427
		Usage: "HTTP-RPC server listening port",
428
		Value: node.DefaultHTTPPort,
429
	}
430 431
	RPCCORSDomainFlag = cli.StringFlag{
		Name:  "rpccorsdomain",
432
		Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
433 434
		Value: "",
	}
435 436 437
	RPCVirtualHostsFlag = cli.StringFlag{
		Name:  "rpcvhosts",
		Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
438
		Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
439
	}
440
	RPCApiFlag = cli.StringFlag{
441
		Name:  "rpcapi",
442
		Usage: "API's offered over the HTTP-RPC interface",
443
		Value: "",
444
	}
445 446 447 448 449 450
	IPCDisabledFlag = cli.BoolFlag{
		Name:  "ipcdisable",
		Usage: "Disable the IPC-RPC server",
	}
	IPCPathFlag = DirectoryFlag{
		Name:  "ipcpath",
451
		Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
452
	}
453
	WSEnabledFlag = cli.BoolFlag{
454
		Name:  "ws",
455 456 457 458 459
		Usage: "Enable the WS-RPC server",
	}
	WSListenAddrFlag = cli.StringFlag{
		Name:  "wsaddr",
		Usage: "WS-RPC server listening interface",
460
		Value: node.DefaultWSHost,
461 462 463 464
	}
	WSPortFlag = cli.IntFlag{
		Name:  "wsport",
		Usage: "WS-RPC server listening port",
465
		Value: node.DefaultWSPort,
466 467 468 469
	}
	WSApiFlag = cli.StringFlag{
		Name:  "wsapi",
		Usage: "API's offered over the WS-RPC interface",
470
		Value: "",
471
	}
472 473 474
	WSAllowedOriginsFlag = cli.StringFlag{
		Name:  "wsorigins",
		Usage: "Origins from which to accept websockets requests",
475
		Value: "",
476
	}
477 478
	ExecFlag = cli.StringFlag{
		Name:  "exec",
479
		Usage: "Execute JavaScript statement",
480
	}
481
	PreloadJSFlag = cli.StringFlag{
482 483 484
		Name:  "preload",
		Usage: "Comma separated list of JavaScript files to preload into the console",
	}
485

486 487 488
	// Network Settings
	MaxPeersFlag = cli.IntFlag{
		Name:  "maxpeers",
489
		Usage: "Maximum number of network peers (network disabled if set to 0)",
490
		Value: 25,
491
	}
492 493 494 495 496
	MaxPendingPeersFlag = cli.IntFlag{
		Name:  "maxpendpeers",
		Usage: "Maximum number of pending connection attempts (defaults used if set to 0)",
		Value: 0,
	}
497 498 499 500 501
	ListenPortFlag = cli.IntFlag{
		Name:  "port",
		Usage: "Network listening port",
		Value: 30303,
	}
502
	BootnodesFlag = cli.StringFlag{
503
		Name:  "bootnodes",
504 505 506 507 508 509 510 511 512 513 514
		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)",
515
		Value: "",
516 517 518 519 520 521 522 523 524 525 526
	}
	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",
527
		Usage: "NAT port mapping mechanism (any|none|upnp|pmp|extip:<IP>)",
528 529
		Value: "any",
	}
530 531 532 533
	NoDiscoverFlag = cli.BoolFlag{
		Name:  "nodiscover",
		Usage: "Disables the peer discovery mechanism (manual peer addition)",
	}
534 535 536 537
	DiscoveryV5Flag = cli.BoolFlag{
		Name:  "v5disc",
		Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
	}
538 539 540 541 542
	NetrestrictFlag = cli.StringFlag{
		Name:  "netrestrict",
		Usage: "Restricts network communication to the given IP networks (CIDR masks)",
	}

543
	// ATM the url is left to the user and deployment to
zelig's avatar
zelig committed
544 545
	JSpathFlag = cli.StringFlag{
		Name:  "jspath",
546
		Usage: "JavaScript root path for `loadScript`",
zelig's avatar
zelig committed
547 548
		Value: ".",
	}
549 550

	// Gas price oracle settings
551 552 553
	GpoBlocksFlag = cli.IntFlag{
		Name:  "gpoblocks",
		Usage: "Number of recent blocks to check for gas prices",
554
		Value: eth.DefaultConfig.GPO.Blocks,
zsfelfoldi's avatar
zsfelfoldi committed
555
	}
556 557 558
	GpoPercentileFlag = cli.IntFlag{
		Name:  "gpopercentile",
		Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices",
559
		Value: eth.DefaultConfig.GPO.Percentile,
zsfelfoldi's avatar
zsfelfoldi committed
560
	}
561 562 563 564 565 566 567 568 569 570 571 572 573 574
	WhisperEnabledFlag = cli.BoolFlag{
		Name:  "shh",
		Usage: "Enable Whisper",
	}
	WhisperMaxMessageSizeFlag = cli.IntFlag{
		Name:  "shh.maxmessagesize",
		Usage: "Max message size accepted",
		Value: int(whisper.DefaultMaxMessageSize),
	}
	WhisperMinPOWFlag = cli.Float64Flag{
		Name:  "shh.pow",
		Usage: "Minimum POW accepted",
		Value: whisper.DefaultMinimumPoW,
	}
575 576 577 578
	WhisperRestrictConnectionBetweenLightClientsFlag = cli.BoolFlag{
		Name:  "shh.restrict-light",
		Usage: "Restrict connection between two whisper light clients",
	}
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617

	// 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",
	}
	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",
	}
618 619 620 621 622 623 624 625 626 627 628

	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: "",
	}
629 630
)

631
// MakeDataDir retrieves the currently requested data directory, terminating
632 633
// 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.
634
func MakeDataDir(ctx *cli.Context) string {
635
	if path := ctx.GlobalString(DataDirFlag.Name); path != "" {
636
		if ctx.GlobalBool(TestnetFlag.Name) {
637
			return filepath.Join(path, "testnet")
638
		}
639 640 641
		if ctx.GlobalBool(RinkebyFlag.Name) {
			return filepath.Join(path, "rinkeby")
		}
642
		return path
643
	}
644
	Fatalf("Cannot determine default data directory, please set manually (--datadir)")
645
	return ""
646 647
}

648
// setNodeKey creates a node key from set command line flags, either loading it
649 650
// 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.
651
func setNodeKey(ctx *cli.Context, cfg *p2p.Config) {
652 653 654
	var (
		hex  = ctx.GlobalString(NodeKeyHexFlag.Name)
		file = ctx.GlobalString(NodeKeyFileFlag.Name)
655 656
		key  *ecdsa.PrivateKey
		err  error
657
	)
658 659
	switch {
	case file != "" && hex != "":
660
		Fatalf("Options %q and %q are mutually exclusive", NodeKeyFileFlag.Name, NodeKeyHexFlag.Name)
661 662
	case file != "":
		if key, err = crypto.LoadECDSA(file); err != nil {
663
			Fatalf("Option %q: %v", NodeKeyFileFlag.Name, err)
664
		}
665
		cfg.PrivateKey = key
666 667
	case hex != "":
		if key, err = crypto.HexToECDSA(hex); err != nil {
668
			Fatalf("Option %q: %v", NodeKeyHexFlag.Name, err)
669
		}
670
		cfg.PrivateKey = key
671 672 673
	}
}

674 675
// setNodeUserIdent creates the user identifier from CLI flags.
func setNodeUserIdent(ctx *cli.Context, cfg *node.Config) {
676
	if identity := ctx.GlobalString(IdentityFlag.Name); len(identity) > 0 {
677
		cfg.UserIdent = identity
678 679 680
	}
}

681
// setBootstrapNodes creates a list of bootstrap nodes from the command line
682
// flags, reverting to pre-configured ones if none have been specified.
683
func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) {
684
	urls := params.MainnetBootnodes
685
	switch {
686 687 688 689 690 691
	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), ",")
		}
692
	case ctx.GlobalBool(TestnetFlag.Name):
693
		urls = params.TestnetBootnodes
694 695
	case ctx.GlobalBool(RinkebyFlag.Name):
		urls = params.RinkebyBootnodes
696 697
	case cfg.BootstrapNodes != nil:
		return // already set, don't apply defaults.
698 699
	}

700
	cfg.BootstrapNodes = make([]*enode.Node, 0, len(urls))
701
	for _, url := range urls {
702
		node, err := enode.ParseV4(url)
703
		if err != nil {
704
			log.Crit("Bootstrap URL invalid", "enode", url, "err", err)
705
		}
706
		cfg.BootstrapNodes = append(cfg.BootstrapNodes, node)
707 708 709
	}
}

710
// setBootstrapNodesV5 creates a list of bootstrap nodes from the command line
711
// flags, reverting to pre-configured ones if none have been specified.
712
func setBootstrapNodesV5(ctx *cli.Context, cfg *p2p.Config) {
713
	urls := params.DiscoveryV5Bootnodes
714
	switch {
715 716 717 718 719 720
	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), ",")
		}
721
	case ctx.GlobalBool(RinkebyFlag.Name):
722
		urls = params.RinkebyBootnodes
723
	case cfg.BootstrapNodesV5 != nil:
724
		return // already set, don't apply defaults.
725 726
	}

727
	cfg.BootstrapNodesV5 = make([]*discv5.Node, 0, len(urls))
728
	for _, url := range urls {
729 730
		node, err := discv5.ParseNode(url)
		if err != nil {
731
			log.Error("Bootstrap URL invalid", "enode", url, "err", err)
732 733
			continue
		}
734
		cfg.BootstrapNodesV5 = append(cfg.BootstrapNodesV5, node)
735 736 737
	}
}

738
// setListenAddress creates a TCP listening address string from set command
739
// line flags.
740 741 742 743
func setListenAddress(ctx *cli.Context, cfg *p2p.Config) {
	if ctx.GlobalIsSet(ListenPortFlag.Name) {
		cfg.ListenAddr = fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name))
	}
744 745
}

746 747 748 749 750 751 752 753
// 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
754 755 756
	}
}

757 758 759
// splitAndTrim splits input separated by a comma
// and trims excessive white space from the substrings.
func splitAndTrim(input string) []string {
760 761 762 763 764 765 766
	result := strings.Split(input, ",")
	for i, r := range result {
		result[i] = strings.TrimSpace(r)
	}
	return result
}

767
// setHTTP creates the HTTP RPC listener interface string from the set
768
// command line flags, returning empty if the HTTP endpoint is disabled.
769 770 771 772 773 774 775 776 777 778 779 780
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) {
781
		cfg.HTTPCors = splitAndTrim(ctx.GlobalString(RPCCORSDomainFlag.Name))
782 783
	}
	if ctx.GlobalIsSet(RPCApiFlag.Name) {
784
		cfg.HTTPModules = splitAndTrim(ctx.GlobalString(RPCApiFlag.Name))
785
	}
786 787 788
	if ctx.GlobalIsSet(RPCVirtualHostsFlag.Name) {
		cfg.HTTPVirtualHosts = splitAndTrim(ctx.GlobalString(RPCVirtualHostsFlag.Name))
	}
789 790
}

791
// setWS creates the WebSocket RPC listener interface string from the set
792
// command line flags, returning empty if the HTTP endpoint is disabled.
793 794 795 796 797 798 799 800 801 802 803 804
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) {
805
		cfg.WSOrigins = splitAndTrim(ctx.GlobalString(WSAllowedOriginsFlag.Name))
806 807
	}
	if ctx.GlobalIsSet(WSApiFlag.Name) {
808
		cfg.WSModules = splitAndTrim(ctx.GlobalString(WSApiFlag.Name))
809 810 811 812 813 814 815 816 817 818 819 820
	}
}

// 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)
821 822 823
	}
}

824
// makeDatabaseHandles raises out the number of allowed file handles per process
825
// for Geth and returns half of the allowance to assign to the database.
826
func makeDatabaseHandles() int {
827
	limit, err := fdlimit.Current()
828
	if err != nil {
829
		Fatalf("Failed to retrieve file descriptor allowance: %v", err)
830
	}
831 832 833 834 835
	if limit < 2048 {
		if err := fdlimit.Raise(2048); err != nil {
			Fatalf("Failed to raise file descriptor allowance: %v", err)
		}
	}
836 837 838 839 840 841
	if limit > 2048 { // cap database file descriptors even if more is available
		limit = 2048
	}
	return limit / 2 // Leave half for networking and other stuff
}

842 843
// MakeAddress converts an account specified directly as a hex encoded string or
// a key index in the key store to an internal account representation.
844
func MakeAddress(ks *keystore.KeyStore, account string) (accounts.Account, error) {
845 846
	// If the specified account is a valid address, return it
	if common.IsHexAddress(account) {
Felix Lange's avatar
Felix Lange committed
847
		return accounts.Account{Address: common.HexToAddress(account)}, nil
848 849 850
	}
	// Otherwise try to interpret the account as a keystore index
	index, err := strconv.Atoi(account)
851
	if err != nil || index < 0 {
Felix Lange's avatar
Felix Lange committed
852
		return accounts.Account{}, fmt.Errorf("invalid account address or index %q", account)
853
	}
854 855 856 857 858 859
	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("-------------------------------------------------------------------")

860 861 862 863 864
	accs := ks.Accounts()
	if len(accs) <= index {
		return accounts.Account{}, fmt.Errorf("index %d higher than number of accounts %d", index, len(accs))
	}
	return accs[index], nil
865 866
}

867
// setEtherbase retrieves the etherbase either from the directly specified
868
// command line flags or from the keystore if CLI indexed.
869
func setEtherbase(ctx *cli.Context, ks *keystore.KeyStore, cfg *eth.Config) {
870 871 872 873 874 875 876 877 878 879 880
	// 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)
881
		if err != nil {
882
			Fatalf("Invalid miner etherbase: %v", err)
883 884
		}
		cfg.Etherbase = account.Address
885
	}
886 887
}

888
// MakePasswordList reads password lines from the file specified by the global --password flag.
889
func MakePasswordList(ctx *cli.Context) []string {
890 891 892 893 894 895
	path := ctx.GlobalString(PasswordFileFlag.Name)
	if path == "" {
		return nil
	}
	text, err := ioutil.ReadFile(path)
	if err != nil {
896
		Fatalf("Failed to read password file: %v", err)
897 898 899 900 901
	}
	lines := strings.Split(string(text), "\n")
	// Sanitise DOS line endings.
	for i := range lines {
		lines[i] = strings.TrimRight(lines[i], "\r")
902
	}
903
	return lines
904 905
}

906 907 908 909 910 911 912
func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
	setNodeKey(ctx, cfg)
	setNAT(ctx, cfg)
	setListenAddress(ctx, cfg)
	setBootstrapNodes(ctx, cfg)
	setBootstrapNodesV5(ctx, cfg)

913
	lightClient := ctx.GlobalString(SyncModeFlag.Name) == "light"
914 915 916
	lightServer := ctx.GlobalInt(LightServFlag.Name) != 0
	lightPeers := ctx.GlobalInt(LightPeersFlag.Name)

917 918
	if ctx.GlobalIsSet(MaxPeersFlag.Name) {
		cfg.MaxPeers = ctx.GlobalInt(MaxPeersFlag.Name)
919 920 921
		if lightServer && !ctx.GlobalIsSet(LightPeersFlag.Name) {
			cfg.MaxPeers += lightPeers
		}
922 923 924 925 926 927 928
	} else {
		if lightServer {
			cfg.MaxPeers += lightPeers
		}
		if lightClient && ctx.GlobalIsSet(LightPeersFlag.Name) && cfg.MaxPeers < lightPeers {
			cfg.MaxPeers = lightPeers
		}
929
	}
930 931 932 933 934 935 936 937 938
	if !(lightClient || lightServer) {
		lightPeers = 0
	}
	ethPeers := cfg.MaxPeers - lightPeers
	if lightClient {
		ethPeers = 0
	}
	log.Info("Maximum peer count", "ETH", ethPeers, "LES", lightPeers, "total", cfg.MaxPeers)

939 940 941
	if ctx.GlobalIsSet(MaxPendingPeersFlag.Name) {
		cfg.MaxPendingPeers = ctx.GlobalInt(MaxPendingPeersFlag.Name)
	}
942
	if ctx.GlobalIsSet(NoDiscoverFlag.Name) || lightClient {
943
		cfg.NoDiscovery = true
944 945
	}

946 947 948
	// 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
949
	forceV5Discovery := (lightClient || lightServer) && !ctx.GlobalBool(NoDiscoverFlag.Name)
950 951 952 953
	if ctx.GlobalIsSet(DiscoveryV5Flag.Name) {
		cfg.DiscoveryV5 = ctx.GlobalBool(DiscoveryV5Flag.Name)
	} else if forceV5Discovery {
		cfg.DiscoveryV5 = true
954
	}
955

956 957 958
	if netrestrict := ctx.GlobalString(NetrestrictFlag.Name); netrestrict != "" {
		list, err := netutil.ParseNetlist(netrestrict)
		if err != nil {
959
			Fatalf("Option %q: %v", NetrestrictFlag.Name, err)
960
		}
961
		cfg.NetRestrict = list
962 963
	}

964
	if ctx.GlobalBool(DeveloperFlag.Name) {
965 966 967 968 969
		// --dev mode can't use p2p networking.
		cfg.MaxPeers = 0
		cfg.ListenAddr = ":0"
		cfg.NoDiscovery = true
		cfg.DiscoveryV5 = false
970 971 972
	}
}

973 974 975 976 977 978 979 980 981 982 983
// 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)

	switch {
	case ctx.GlobalIsSet(DataDirFlag.Name):
		cfg.DataDir = ctx.GlobalString(DataDirFlag.Name)
984 985
	case ctx.GlobalBool(DeveloperFlag.Name):
		cfg.DataDir = "" // unless explicitly requested, use memory databases
986
	case ctx.GlobalBool(TestnetFlag.Name):
987
		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "testnet")
988 989
	case ctx.GlobalBool(RinkebyFlag.Name):
		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "rinkeby")
990 991 992 993 994 995 996 997
	}

	if ctx.GlobalIsSet(KeyStoreDirFlag.Name) {
		cfg.KeyStoreDir = ctx.GlobalString(KeyStoreDirFlag.Name)
	}
	if ctx.GlobalIsSet(LightKDFFlag.Name) {
		cfg.UseLightweightKDF = ctx.GlobalBool(LightKDFFlag.Name)
	}
998 999 1000
	if ctx.GlobalIsSet(NoUSBFlag.Name) {
		cfg.NoUSB = ctx.GlobalBool(NoUSBFlag.Name)
	}
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
}

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)
	}
}

1012
func setTxPool(ctx *cli.Context, cfg *core.TxPoolConfig) {
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
	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))
			}
		}
	}
1023 1024 1025
	if ctx.GlobalIsSet(TxPoolNoLocalsFlag.Name) {
		cfg.NoLocals = ctx.GlobalBool(TxPoolNoLocalsFlag.Name)
	}
1026 1027 1028 1029 1030 1031
	if ctx.GlobalIsSet(TxPoolJournalFlag.Name) {
		cfg.Journal = ctx.GlobalString(TxPoolJournalFlag.Name)
	}
	if ctx.GlobalIsSet(TxPoolRejournalFlag.Name) {
		cfg.Rejournal = ctx.GlobalDuration(TxPoolRejournalFlag.Name)
	}
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
	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)
	}
}

1055 1056
func setEthash(ctx *cli.Context, cfg *eth.Config) {
	if ctx.GlobalIsSet(EthashCacheDirFlag.Name) {
1057
		cfg.Ethash.CacheDir = ctx.GlobalString(EthashCacheDirFlag.Name)
1058 1059
	}
	if ctx.GlobalIsSet(EthashDatasetDirFlag.Name) {
1060
		cfg.Ethash.DatasetDir = ctx.GlobalString(EthashDatasetDirFlag.Name)
1061 1062
	}
	if ctx.GlobalIsSet(EthashCachesInMemoryFlag.Name) {
1063
		cfg.Ethash.CachesInMem = ctx.GlobalInt(EthashCachesInMemoryFlag.Name)
1064 1065
	}
	if ctx.GlobalIsSet(EthashCachesOnDiskFlag.Name) {
1066
		cfg.Ethash.CachesOnDisk = ctx.GlobalInt(EthashCachesOnDiskFlag.Name)
1067 1068
	}
	if ctx.GlobalIsSet(EthashDatasetsInMemoryFlag.Name) {
1069
		cfg.Ethash.DatasetsInMem = ctx.GlobalInt(EthashDatasetsInMemoryFlag.Name)
1070 1071
	}
	if ctx.GlobalIsSet(EthashDatasetsOnDiskFlag.Name) {
1072
		cfg.Ethash.DatasetsOnDisk = ctx.GlobalInt(EthashDatasetsOnDiskFlag.Name)
1073 1074 1075
	}
}

1076
// checkExclusive verifies that only a single instance of the provided flags was
1077 1078 1079
// set by the user. Each flag might optionally be followed by a string type to
// specialize it further.
func checkExclusive(ctx *cli.Context, args ...interface{}) {
1080
	set := make([]string, 0, 1)
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
	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:
1093
				// Extended flag check, make sure value set doesn't conflict with passed in option
1094 1095
				if ctx.GlobalString(flag.GetName()) == option {
					name += "=" + option
1096
					set = append(set, "--"+name)
1097
				}
1098
				// shift arguments and continue
1099
				i++
1100
				continue
1101 1102 1103 1104 1105 1106 1107

			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
1108
		if ctx.GlobalIsSet(flag.GetName()) {
1109
			set = append(set, "--"+name)
1110 1111
		}
	}
1112
	if len(set) > 1 {
1113
		Fatalf("Flags %v can't be used at the same time", strings.Join(set, ", "))
1114
	}
1115 1116
}

1117 1118
// SetShhConfig applies shh-related command line flags to the config.
func SetShhConfig(ctx *cli.Context, stack *node.Node, cfg *whisper.Config) {
1119 1120
	if ctx.GlobalIsSet(WhisperMaxMessageSizeFlag.Name) {
		cfg.MaxMessageSize = uint32(ctx.GlobalUint(WhisperMaxMessageSizeFlag.Name))
1121
	}
1122 1123
	if ctx.GlobalIsSet(WhisperMinPOWFlag.Name) {
		cfg.MinimumAcceptedPOW = ctx.GlobalFloat64(WhisperMinPOWFlag.Name)
1124
	}
1125 1126 1127
	if ctx.GlobalIsSet(WhisperRestrictConnectionBetweenLightClientsFlag.Name) {
		cfg.RestrictConnectionBetweenLightClients = true
	}
1128 1129
}

1130 1131 1132
// SetEthConfig applies eth-related command line flags to the config.
func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
	// Avoid conflicting network flags
1133
	checkExclusive(ctx, DeveloperFlag, TestnetFlag, RinkebyFlag)
1134
	checkExclusive(ctx, LightServFlag, SyncModeFlag, "light")
1135

1136
	ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
1137 1138
	setEtherbase(ctx, ks, cfg)
	setGPO(ctx, &cfg.GPO)
1139
	setTxPool(ctx, &cfg.TxPool)
1140 1141
	setEthash(ctx, cfg)

1142
	if ctx.GlobalIsSet(SyncModeFlag.Name) {
1143 1144 1145 1146 1147 1148 1149 1150 1151
		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)
	}
	if ctx.GlobalIsSet(NetworkIdFlag.Name) {
1152
		cfg.NetworkId = ctx.GlobalUint64(NetworkIdFlag.Name)
1153 1154
	}

1155 1156
	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheDatabaseFlag.Name) {
		cfg.DatabaseCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheDatabaseFlag.Name) / 100
1157 1158 1159
	}
	cfg.DatabaseHandles = makeDatabaseHandles()

1160 1161 1162 1163 1164
	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"

1165 1166 1167
	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheTrieFlag.Name) {
		cfg.TrieCleanCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheTrieFlag.Name) / 100
	}
1168
	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
1169
		cfg.TrieDirtyCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
1170
	}
1171 1172 1173
	if ctx.GlobalIsSet(MinerNotifyFlag.Name) {
		cfg.MinerNotify = strings.Split(ctx.GlobalString(MinerNotifyFlag.Name), ",")
	}
1174 1175 1176
	if ctx.GlobalIsSet(DocRootFlag.Name) {
		cfg.DocRoot = ctx.GlobalString(DocRootFlag.Name)
	}
1177
	if ctx.GlobalIsSet(MinerLegacyExtraDataFlag.Name) {
1178
		cfg.MinerExtraData = []byte(ctx.GlobalString(MinerLegacyExtraDataFlag.Name))
1179
	}
1180
	if ctx.GlobalIsSet(MinerExtraDataFlag.Name) {
1181
		cfg.MinerExtraData = []byte(ctx.GlobalString(MinerExtraDataFlag.Name))
1182
	}
1183 1184 1185 1186 1187 1188 1189 1190 1191
	if ctx.GlobalIsSet(MinerLegacyGasTargetFlag.Name) {
		cfg.MinerGasFloor = ctx.GlobalUint64(MinerLegacyGasTargetFlag.Name)
	}
	if ctx.GlobalIsSet(MinerGasTargetFlag.Name) {
		cfg.MinerGasFloor = ctx.GlobalUint64(MinerGasTargetFlag.Name)
	}
	if ctx.GlobalIsSet(MinerGasLimitFlag.Name) {
		cfg.MinerGasCeil = ctx.GlobalUint64(MinerGasLimitFlag.Name)
	}
1192
	if ctx.GlobalIsSet(MinerLegacyGasPriceFlag.Name) {
1193
		cfg.MinerGasPrice = GlobalBig(ctx, MinerLegacyGasPriceFlag.Name)
1194 1195
	}
	if ctx.GlobalIsSet(MinerGasPriceFlag.Name) {
1196 1197 1198 1199
		cfg.MinerGasPrice = GlobalBig(ctx, MinerGasPriceFlag.Name)
	}
	if ctx.GlobalIsSet(MinerRecommitIntervalFlag.Name) {
		cfg.MinerRecommit = ctx.Duration(MinerRecommitIntervalFlag.Name)
1200
	}
1201 1202 1203
	if ctx.GlobalIsSet(MinerNoVerfiyFlag.Name) {
		cfg.MinerNoverify = ctx.Bool(MinerNoVerfiyFlag.Name)
	}
1204 1205 1206 1207
	if ctx.GlobalIsSet(VMEnableDebugFlag.Name) {
		// TODO(fjl): force-enable this in --dev mode
		cfg.EnablePreimageRecording = ctx.GlobalBool(VMEnableDebugFlag.Name)
	}
1208

1209 1210 1211 1212 1213 1214 1215 1216
	if ctx.GlobalIsSet(EWASMInterpreterFlag.Name) {
		cfg.EWASMInterpreter = ctx.GlobalString(EWASMInterpreterFlag.Name)
	}

	if ctx.GlobalIsSet(EVMInterpreterFlag.Name) {
		cfg.EVMInterpreter = ctx.GlobalString(EVMInterpreterFlag.Name)
	}

1217
	// Override any default configs for hard coded networks.
1218
	switch {
1219
	case ctx.GlobalBool(TestnetFlag.Name):
1220
		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
1221
			cfg.NetworkId = 3
1222
		}
1223
		cfg.Genesis = core.DefaultTestnetGenesisBlock()
1224 1225 1226 1227 1228
	case ctx.GlobalBool(RinkebyFlag.Name):
		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
			cfg.NetworkId = 4
		}
		cfg.Genesis = core.DefaultRinkebyGenesisBlock()
1229
	case ctx.GlobalBool(DeveloperFlag.Name):
1230 1231 1232
		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
			cfg.NetworkId = 1337
		}
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
		// 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)
1252
		if !ctx.GlobalIsSet(MinerGasPriceFlag.Name) && !ctx.GlobalIsSet(MinerLegacyGasPriceFlag.Name) {
1253
			cfg.MinerGasPrice = big.NewInt(1)
1254 1255
		}
	}
1256
	// TODO(fjl): move trie cache generations into config
1257 1258 1259
	if gen := ctx.GlobalInt(TrieCacheGenFlag.Name); gen > 0 {
		state.MaxTrieCacheGen = uint16(gen)
	}
1260
}
1261

1262 1263 1264 1265 1266 1267 1268
// 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)
}

1269 1270 1271 1272 1273 1274 1275
// RegisterEthService adds an Ethereum client to the stack.
func RegisterEthService(stack *node.Node, cfg *eth.Config) {
	var err error
	if cfg.SyncMode == downloader.LightSync {
		err = stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
			return les.New(ctx, cfg)
		})
1276
	} else {
1277 1278 1279 1280
		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)
1281 1282 1283
				fullNode.AddLesServer(ls)
			}
			return fullNode, err
1284 1285 1286 1287
		})
	}
	if err != nil {
		Fatalf("Failed to register the Ethereum service: %v", err)
1288
	}
1289 1290
}

1291
// RegisterDashboardService adds a dashboard to the stack.
1292
func RegisterDashboardService(stack *node.Node, cfg *dashboard.Config, commit string) {
1293
	stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
1294
		return dashboard.New(cfg, commit, ctx.ResolvePath("logs")), nil
1295 1296 1297
	})
}

1298
// RegisterShhService configures Whisper and adds it to the given node.
1299 1300 1301 1302
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 {
1303
		Fatalf("Failed to register the Whisper service: %v", err)
1304
	}
1305 1306
}

1307
// RegisterEthStatsService configures the Ethereum Stats daemon and adds it to
1308
// the given node.
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
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(&ethServ)

		var lesServ *les.LightEthereum
		ctx.Service(&lesServ)

		return ethstats.New(url, ethServ, lesServ)
	}); err != nil {
1320
		Fatalf("Failed to register the Ethereum Stats service: %v", err)
1321 1322 1323
	}
}

1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
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,
			})
		}
	}
}

1345
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
1346
func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database {
1347
	var (
1348
		cache   = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheDatabaseFlag.Name) / 100
1349
		handles = makeDatabaseHandles()
1350
	)
1351
	name := "chaindata"
1352
	if ctx.GlobalString(SyncModeFlag.Name) == "light" {
1353 1354
		name = "lightchaindata"
	}
1355
	chainDb, err := stack.OpenDatabase(name, cache, handles)
1356
	if err != nil {
1357
		Fatalf("Could not open database: %v", err)
1358
	}
1359 1360 1361
	return chainDb
}

1362 1363 1364
func MakeGenesis(ctx *cli.Context) *core.Genesis {
	var genesis *core.Genesis
	switch {
1365
	case ctx.GlobalBool(TestnetFlag.Name):
1366
		genesis = core.DefaultTestnetGenesisBlock()
1367 1368
	case ctx.GlobalBool(RinkebyFlag.Name):
		genesis = core.DefaultRinkebyGenesisBlock()
1369 1370
	case ctx.GlobalBool(DeveloperFlag.Name):
		Fatalf("Developer chains are ephemeral")
1371 1372 1373 1374
	}
	return genesis
}

1375
// MakeChain creates a chain manager from set command line flags.
1376
func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chainDb ethdb.Database) {
1377
	var err error
1378
	chainDb = MakeChainDatabase(ctx, stack)
1379

1380 1381 1382 1383
	config, _, err := core.SetupGenesisBlock(chainDb, MakeGenesis(ctx))
	if err != nil {
		Fatalf("%v", err)
	}
1384 1385 1386 1387 1388 1389
	var engine consensus.Engine
	if config.Clique != nil {
		engine = clique.New(config.Clique, chainDb)
	} else {
		engine = ethash.NewFaker()
		if !ctx.GlobalBool(FakePoWFlag.Name) {
1390 1391 1392 1393 1394 1395 1396
			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,
1397
			}, nil, false)
1398 1399
		}
	}
1400 1401 1402 1403
	if gcmode := ctx.GlobalString(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
		Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)
	}
	cache := &core.CacheConfig{
1404 1405 1406 1407 1408 1409 1410
		Disabled:       ctx.GlobalString(GCModeFlag.Name) == "archive",
		TrieCleanLimit: eth.DefaultConfig.TrieCleanCache,
		TrieDirtyLimit: eth.DefaultConfig.TrieDirtyCache,
		TrieTimeLimit:  eth.DefaultConfig.TrieTimeout,
	}
	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheTrieFlag.Name) {
		cache.TrieCleanLimit = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheTrieFlag.Name) / 100
1411 1412
	}
	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
1413
		cache.TrieDirtyLimit = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
1414
	}
1415
	vmcfg := vm.Config{EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name)}
1416
	chain, err = core.NewBlockChain(chainDb, cache, config, engine, vmcfg, nil)
obscuren's avatar
obscuren committed
1417
	if err != nil {
1418
		Fatalf("Can't create BlockChain: %v", err)
obscuren's avatar
obscuren committed
1419
	}
1420
	return chain, chainDb
1421
}
1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438

// 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
}
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462

// 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)
	}
}