nimbus-eth1/nimbus/config.nim

772 lines
25 KiB
Nim
Raw Normal View History

2018-04-27 08:53:53 +00:00
# Nimbus
# Copyright (c) 2018-2019 Status Research & Development GmbH
2018-04-27 08:53:53 +00:00
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
import
parseopt, strutils, macros, os, times,
2019-04-17 01:56:28 +00:00
chronos, eth/[keys, common, p2p, net/nat], chronicles, nimcrypto/hash,
2019-08-15 11:08:07 +00:00
eth/p2p/bootnodes, eth/p2p/rlpx_protocols/whisper_protocol,
./db/select_backend,
./vm/interpreter/vm_forks
2018-04-27 08:53:53 +00:00
2019-01-15 15:25:14 +00:00
const
2018-04-27 08:53:53 +00:00
NimbusName* = "Nimbus"
## project name string
2018-04-27 08:53:53 +00:00
NimbusMajor*: int = 0
## is the major number of Nimbus' version.
NimbusMinor*: int = 0
## is the minor number of Nimbus' version.
NimbusPatch*: int = 1
## is the patch number of Nimbus' version.
NimbusVersion* = $NimbusMajor & "." & $NimbusMinor & "." & $NimbusPatch
## is the version of Nimbus as a string.
2019-01-15 15:25:14 +00:00
NimbusIdent* = "$1/$2 ($3/$4)" % [NimbusName, NimbusVersion, hostCPU, hostOS]
## project ident name for networking services
let
NimbusCopyright* = "Copyright (C) 2018-" & $(now().utc.year) & " Status Research & Development GmbH"
## copyright string
2018-06-20 17:27:32 +00:00
NimbusHeader* = NimbusName & " Version " & NimbusVersion &
" [" & hostOS & ": " & hostCPU & ", " & nimbus_db_backend & "]\r\n" &
2018-06-20 17:27:32 +00:00
NimbusCopyright
## is the header which printed, when nimbus binary got executed
2018-04-27 08:53:53 +00:00
type
ConfigStatus* = enum
## Configuration status flags
2018-06-20 17:27:32 +00:00
Success, ## Success
EmptyOption, ## No options in category
ErrorUnknownOption, ## Unknown option in command line found
ErrorParseOption, ## Error in parsing command line option
ErrorIncorrectOption, ## Option has incorrect value
Error ## Unspecified error
2018-04-27 08:53:53 +00:00
RpcFlags* {.pure.} = enum
## RPC flags
2018-06-20 17:27:32 +00:00
Enabled ## RPC enabled
Eth ## enable eth_ set of RPC API
Shh ## enable shh_ set of RPC API
Debug ## enable debug_ set of RPC API
2018-04-27 08:53:53 +00:00
ProtocolFlags* {.pure.} = enum
## Protocol flags
Eth ## enable eth subprotocol
Shh ## enable whisper subprotocol
Les ## enable les subprotocol
2018-04-27 08:53:53 +00:00
RpcConfiguration* = object
## JSON-RPC configuration object
2018-06-20 17:27:32 +00:00
flags*: set[RpcFlags] ## RPC flags
binds*: seq[TransportAddress] ## RPC bind address
2018-04-27 08:53:53 +00:00
2018-08-01 12:50:44 +00:00
PublicNetwork* = enum
CustomNet = 0
MainNet = 1
MordenNet = 2
RopstenNet = 3
RinkebyNet = 4
KovanNet = 42
2018-04-27 08:53:53 +00:00
NetworkFlags* = enum
## Ethereum network flags
2018-06-20 17:27:32 +00:00
NoDiscover, ## Peer discovery disabled
V5Discover, ## Dicovery V5 enabled
2018-04-27 08:53:53 +00:00
DebugFlags* {.pure.} = enum
## Debug selection flags
2018-06-20 17:27:32 +00:00
Enabled, ## Debugging enabled
Test1, ## Test1 enabled
Test2, ## Test2 enabled
Test3 ## Test3 enabled
2018-04-27 08:53:53 +00:00
NetConfiguration* = object
## Network configuration object
2018-06-20 17:27:32 +00:00
flags*: set[NetworkFlags] ## Network flags
bootNodes*: seq[ENode] ## List of bootnodes
staticNodes*: seq[ENode] ## List of static nodes to connect to
2018-06-20 17:27:32 +00:00
bindPort*: uint16 ## Main TCP bind port
discPort*: uint16 ## Discovery UDP bind port
metricsServer*: bool ## Enable metrics server
metricsServerPort*: uint16 ## metrics HTTP server port
2018-06-20 17:27:32 +00:00
maxPeers*: int ## Maximum allowed number of peers
maxPendingPeers*: int ## Maximum allowed pending peers
networkId*: uint ## Network ID as integer
2018-06-20 17:27:32 +00:00
ident*: string ## Server ident name string
nodeKey*: PrivateKey ## Server private key
2019-04-17 01:56:28 +00:00
nat*: NatStrategy ## NAT strategy
externalIP*: string ## user-provided external IP
protocols*: set[ProtocolFlags]## Enabled subprotocols
2018-04-27 08:53:53 +00:00
DebugConfiguration* = object
## Debug configuration object
2018-06-20 17:27:32 +00:00
flags*: set[DebugFlags] ## Debug flags
logLevel*: LogLevel ## Log level
logFile*: string ## Log file
logMetrics*: bool ## Enable metrics logging
logMetricsInterval*: int ## Metrics logging interval
2018-04-27 08:53:53 +00:00
2018-11-30 03:03:30 +00:00
PruneMode* {.pure.} = enum
Full
Archive
2018-08-01 12:50:44 +00:00
ChainConfig* = object
chainId*: uint
homesteadBlock*: BlockNumber
daoForkBlock*: BlockNumber
daoForkSupport*: bool
# EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150)
eip150Block*: BlockNumber
eip150Hash*: Hash256
eip155Block*: BlockNumber
eip158Block*: BlockNumber
byzantiumBlock*: BlockNumber
constantinopleBlock*: BlockNumber
2018-04-27 08:53:53 +00:00
NimbusConfiguration* = ref object
## Main Nimbus configuration object
dataDir*: string
keyFile*: string
2018-11-30 03:03:30 +00:00
prune*: PruneMode
2018-06-20 17:27:32 +00:00
rpc*: RpcConfiguration ## JSON-RPC configuration
net*: NetConfiguration ## Network configuration
debug*: DebugConfiguration ## Debug configuration
shh*: WhisperConfig ## Whisper configuration
2018-04-27 08:53:53 +00:00
const
defaultRpcApi = {RpcFlags.Eth, RpcFlags.Shh}
defaultProtocols = {ProtocolFlags.Eth, ProtocolFlags.Shh}
defaultLogLevel = LogLevel.WARN
defaultNetwork = MainNet
2018-04-27 08:53:53 +00:00
var nimbusConfig {.threadvar.}: NimbusConfiguration
2018-06-20 17:27:32 +00:00
proc getConfiguration*(): NimbusConfiguration {.gcsafe.}
2018-04-27 08:53:53 +00:00
2018-08-01 12:50:44 +00:00
proc publicChainConfig*(id: PublicNetwork): ChainConfig =
result = case id
of MainNet:
ChainConfig(
chainId: MainNet.uint,
homesteadBlock: forkBlocks[FkHomestead],
daoForkBlock: forkBlocks[FkDao],
2018-08-01 12:50:44 +00:00
daoForkSupport: true,
eip150Block: forkBlocks[FkTangerine],
2018-08-01 12:50:44 +00:00
eip150Hash: toDigest("2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
eip155Block: forkBlocks[FkSpurious],
eip158Block: forkBlocks[FkSpurious],
byzantiumBlock: forkBlocks[FkByzantium]
2018-08-01 12:50:44 +00:00
)
of RopstenNet:
ChainConfig(
chainId: RopstenNet.uint,
homesteadBlock: 0.toBlockNumber,
2018-08-01 12:50:44 +00:00
daoForkSupport: true,
eip150Block: 0.toBlockNumber,
2018-08-01 12:50:44 +00:00
eip150Hash: toDigest("41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"),
eip155Block: 10.toBlockNumber,
eip158Block: 10.toBlockNumber,
byzantiumBlock: 1700000.toBlockNumber
2018-08-01 12:50:44 +00:00
)
of RinkebyNet:
ChainConfig(
chainId: RinkebyNet.uint,
homesteadBlock: 1.toBlockNumber,
2018-08-01 12:50:44 +00:00
daoForkSupport: true,
eip150Block: 2.toBlockNumber,
2018-08-01 12:50:44 +00:00
eip150Hash: toDigest("9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"),
eip155Block: 3.toBlockNumber,
eip158Block: 3.toBlockNumber,
byzantiumBlock: 1035301.toBlockNumber
2018-08-01 12:50:44 +00:00
)
else:
2018-08-03 11:10:07 +00:00
error "No chain config for public network", networkId = id
doAssert(false, "No chain config for " & $id)
ChainConfig()
2018-08-01 12:50:44 +00:00
result.chainId = uint(id)
2018-04-27 08:53:53 +00:00
proc processList(v: string, o: var seq[string]) =
## Process comma-separated list of strings.
2018-04-27 08:53:53 +00:00
if len(v) > 0:
for n in v.split({' ', ','}):
if len(n) > 0:
o.add(n)
2019-01-08 11:29:56 +00:00
proc processInteger*(v: string, o: var int): ConfigStatus =
## Convert string to integer.
2018-04-27 08:53:53 +00:00
try:
o = parseInt(v)
2018-04-30 07:24:51 +00:00
result = Success
except:
result = ErrorParseOption
proc processFloat*(v: string, o: var float): ConfigStatus =
## Convert string to float.
try:
o = parseFloat(v)
result = Success
except:
result = ErrorParseOption
2018-06-20 17:27:32 +00:00
proc processAddressPortsList(v: string,
o: var seq[TransportAddress]): ConfigStatus =
## Convert <hostname:port>;...;<hostname:port> to list of `TransportAddress`.
var list = newSeq[string]()
processList(v, list)
for item in list:
2018-06-20 17:27:32 +00:00
var tas4: seq[TransportAddress]
var tas6: seq[TransportAddress]
try:
tas4 = resolveTAddress(item, IpAddressFamily.IPv4)
except:
discard
try:
tas6 = resolveTAddress(item, IpAddressFamily.IPv6)
except:
discard
if len(tas4) == 0 and len(tas6) == 0:
result = ErrorParseOption
break
2018-06-20 17:27:32 +00:00
else:
for a in tas4: o.add(a)
for a in tas6: o.add(a)
result = Success
proc processRpcApiList(v: string, flags: var set[RpcFlags]): ConfigStatus =
var list = newSeq[string]()
processList(v, list)
result = Success
for item in list:
case item.toLowerAscii()
of "eth": flags.incl RpcFlags.Eth
of "shh": flags.incl RpcFlags.Shh
of "debug": flags.incl RpcFlags.Debug
else:
warn "unknown rpc api", name = item
result = ErrorIncorrectOption
proc processProtocolList(v: string, flags: var set[ProtocolFlags]): ConfigStatus =
var list = newSeq[string]()
processList(v, list)
result = Success
for item in list:
case item.toLowerAscii()
of "eth": flags.incl ProtocolFlags.Eth
of "shh": flags.incl ProtocolFlags.Shh
of "les": flags.incl ProtocolFlags.Les
else:
warn "unknown protocol", name = item
result = ErrorIncorrectOption
proc processENode(v: string, o: var ENode): ConfigStatus =
## Convert string to ENode.
let res = initENode(v, o)
if res == ENodeStatus.Success:
result = Success
else:
result = ErrorParseOption
proc processENodesList(v: string, o: var seq[ENode]): ConfigStatus =
## Convert comma-separated list of strings to list of ENode.
var
node: ENode
list = newSeq[string]()
processList(v, list)
for item in list:
result = processENode(item, node)
if result == Success:
o.add(node)
else:
break
2018-04-30 07:24:51 +00:00
proc processPrivateKey(v: string, o: var PrivateKey): ConfigStatus =
## Convert hexadecimal string to private key object.
try:
o = initPrivateKey(v)
result = Success
except:
result = ErrorParseOption
# proc processHexBytes(v: string, o: var seq[byte]): ConfigStatus =
# ## Convert hexadecimal string to seq[byte].
# try:
# o = fromHex(v)
# result = Success
# except:
# result = ErrorParseOption
# proc processHexString(v: string, o: var string): ConfigStatus =
# ## Convert hexadecimal string to string.
# try:
# o = parseHexStr(v)
# result = Success
# except:
# result = ErrorParseOption
# proc processJson(v: string, o: var JsonNode): ConfigStatus =
# ## Convert string to JSON.
# try:
# o = parseJson(v)
# result = Success
# except:
# result = ErrorParseOption
2018-11-30 03:03:30 +00:00
proc processPruneList(v: string, flags: var PruneMode): ConfigStatus =
var list = newSeq[string]()
processList(v, list)
result = Success
for item in list:
case item.toLowerAscii()
of "full": flags = PruneMode.Full
of "archive": flags = PruneMode.Archive
else:
warn "unknown prune flags", name = item
result = ErrorIncorrectOption
proc processEthArguments(key, value: string): ConfigStatus =
result = Success
let config = getConfiguration()
case key.toLowerAscii()
of "keyfile":
if fileExists(value):
config.keyFile = value
else:
result = ErrorIncorrectOption
2018-12-28 08:24:57 +00:00
of "datadir":
config.dataDir = value
2018-11-30 03:03:30 +00:00
of "prune":
result = processPruneList(value, config.prune)
else:
result = EmptyOption
2018-04-27 08:53:53 +00:00
proc processRpcArguments(key, value: string): ConfigStatus =
## Processes only `RPC` related command line options
result = Success
let config = getConfiguration()
let skey = key.toLowerAscii()
if skey == "rpc":
if RpcFlags.Enabled notin config.rpc.flags:
config.rpc.flags.incl(RpcFlags.Enabled)
config.rpc.flags.incl(defaultRpcApi)
2018-04-27 08:53:53 +00:00
elif skey == "rpcbind":
2018-06-20 17:27:32 +00:00
config.rpc.binds.setLen(0)
result = processAddressPortsList(value, config.rpc.binds)
elif skey == "rpcapi":
if RpcFlags.Enabled in config.rpc.flags:
config.rpc.flags.excl(defaultRpcApi)
else:
config.rpc.flags.incl(RpcFlags.Enabled)
result = processRpcApiList(value, config.rpc.flags)
2018-04-27 08:53:53 +00:00
else:
result = EmptyOption
2018-08-01 12:50:44 +00:00
proc setBootnodes(onodes: var seq[ENode], nodeUris: openarray[string]) =
2018-06-20 17:27:32 +00:00
var node: ENode
2018-08-01 12:50:44 +00:00
onodes = newSeqOfCap[ENode](nodeUris.len)
for item in nodeUris:
2018-06-20 17:27:32 +00:00
doAssert(processENode(item, node) == Success)
2018-08-01 12:50:44 +00:00
onodes.add(node)
2018-06-20 17:27:32 +00:00
2018-08-02 08:18:12 +00:00
macro availableEnumValues(T: type enum): untyped =
let impl = getTypeImpl(T)[1].getTypeImpl()
result = newNimNode(nnkBracket)
for i in 1 ..< impl.len: result.add(newCall("uint", copyNimTree(impl[i])))
2018-08-01 12:50:44 +00:00
proc toPublicNetwork*(id: uint): PublicNetwork {.inline.} =
2018-08-02 08:18:12 +00:00
if id in availableEnumValues(PublicNetwork):
result = PublicNetwork(id)
2018-08-01 12:50:44 +00:00
proc setNetwork(conf: var NetConfiguration, id: PublicNetwork) =
2018-06-20 17:27:32 +00:00
## Set network id and default network bootnodes
2018-08-01 12:50:44 +00:00
conf.networkId = uint(id)
case id
2018-06-20 17:27:32 +00:00
of MainNet:
conf.bootNodes.setBootnodes(MainnetBootnodes)
of MordenNet:
2018-08-01 12:50:44 +00:00
discard
2018-06-20 17:27:32 +00:00
of RopstenNet:
conf.bootNodes.setBootnodes(RopstenBootnodes)
of RinkebyNet:
conf.bootNodes.setBootnodes(RinkebyBootnodes)
of KovanNet:
conf.bootNodes.setBootnodes(KovanBootnodes)
of CustomNet:
2018-08-01 12:50:44 +00:00
discard
proc setNetwork(conf: var NetConfiguration, id: uint) =
## Set network id and default network bootnodes
let pubNet = toPublicNetwork(id)
if pubNet == CustomNet:
2018-06-20 17:27:32 +00:00
conf.networkId = id
else:
2018-08-01 12:50:44 +00:00
conf.setNetwork(pubNet)
2018-06-20 17:27:32 +00:00
2018-04-27 08:53:53 +00:00
proc processNetArguments(key, value: string): ConfigStatus =
## Processes only `Networking` related command line options
result = Success
let config = getConfiguration()
let skey = key.toLowerAscii()
if skey == "bootnodes":
2018-09-25 13:30:44 +00:00
result = processENodesList(value, config.net.bootNodes)
2018-04-27 08:53:53 +00:00
elif skey == "bootnodesv4":
2018-06-20 17:27:32 +00:00
result = processENodesList(value, config.net.bootNodes)
2018-04-27 08:53:53 +00:00
elif skey == "bootnodesv5":
2018-06-20 17:27:32 +00:00
result = processENodesList(value, config.net.bootNodes)
elif skey == "staticnodes":
result = processENodesList(value, config.net.staticNodes)
2018-04-27 08:53:53 +00:00
elif skey == "testnet":
2018-06-20 17:27:32 +00:00
config.net.setNetwork(RopstenNet)
2018-04-27 08:53:53 +00:00
elif skey == "mainnet":
2018-06-20 17:27:32 +00:00
config.net.setNetwork(MainNet)
elif skey == "ropsten":
config.net.setNetwork(RopstenNet)
elif skey == "rinkeby":
config.net.setNetwork(RinkebyNet)
elif skey == "kovan":
config.net.setNetwork(KovanNet)
elif skey == "networkid":
var res = 0
result = processInteger(value, res)
if result == Success:
2018-08-01 12:50:44 +00:00
config.net.setNetwork(uint(result))
2018-04-27 08:53:53 +00:00
elif skey == "nodiscover":
config.net.flags.incl(NoDiscover)
elif skey == "v5discover":
config.net.flags.incl(V5Discover)
2018-06-20 17:27:32 +00:00
config.net.bootNodes.setBootnodes(DiscoveryV5Bootnodes)
2018-04-27 08:53:53 +00:00
elif skey == "port":
var res = 0
result = processInteger(value, res)
if result == Success:
config.net.bindPort = uint16(res and 0xFFFF)
elif skey == "discport":
var res = 0
result = processInteger(value, res)
if result == Success:
config.net.discPort = uint16(res and 0xFFFF)
elif skey == "metricsserver" and defined(insecure):
config.net.metricsServer = true
elif skey == "metricsserverport" and defined(insecure):
var res = 0
result = processInteger(value, res)
if result == Success:
config.net.metricsServerPort = uint16(res and 0xFFFF)
2018-04-27 08:53:53 +00:00
elif skey == "maxpeers":
var res = 0
result = processInteger(value, res)
if result == Success:
config.net.maxPeers = res
elif skey == "maxpendpeers":
var res = 0
result = processInteger(value, res)
if result == Success:
config.net.maxPendingPeers = res
elif skey == "nodekey":
var res: PrivateKey
result = processPrivateKey(value, res)
if result == Success:
config.net.nodeKey = res
2018-06-20 17:27:32 +00:00
elif skey == "ident":
config.net.ident = value
2019-04-17 01:56:28 +00:00
elif skey == "nat":
case value.toLowerAscii:
of "any":
config.net.nat = NatAny
of "upnp":
config.net.nat = NatUpnp
of "pmp":
config.net.nat = NatPmp
of "none":
config.net.nat = NatNone
else:
if isIpAddress(value):
config.net.externalIP = value
config.net.nat = NatNone
else:
error "not a valid NAT mechanism, nor a valid IP address", value
result = ErrorParseOption
elif skey == "protocols":
config.net.protocols = {}
result = processProtocolList(value, config.net.protocols)
else:
result = EmptyOption
proc processShhArguments(key, value: string): ConfigStatus =
## Processes only `Shh` related command line options
result = Success
let config = getConfiguration()
let skey = key.toLowerAscii()
if skey == "shh-maxsize":
var res = 0
result = processInteger(value, res)
if result == Success:
config.shh.maxMsgSize = res.uint32
elif skey == "shh-pow":
var res = 0.0
result = processFloat(value, res)
if result == Success:
config.shh.powRequirement = res
elif skey == "shh-light":
config.shh.isLightNode = true
2018-04-27 08:53:53 +00:00
else:
result = EmptyOption
proc processDebugArguments(key, value: string): ConfigStatus =
## Processes only `Debug` related command line options
let config = getConfiguration()
result = Success
let skey = key.toLowerAscii()
if skey == "debug":
config.debug.flags.incl(DebugFlags.Enabled)
elif skey == "test":
var res = newSeq[string]()
processList(value, res)
for item in res:
if item == "test1":
config.debug.flags.incl(DebugFlags.Test1)
elif item == "test2":
config.debug.flags.incl(DebugFlags.Test2)
elif item == "test3":
config.debug.flags.incl(DebugFlags.Test3)
elif skey == "log-level":
try:
let logLevel = parseEnum[LogLevel](value)
if logLevel >= enabledLogLevel:
config.debug.logLevel = logLevel
else:
result = ErrorIncorrectOption
except ValueError:
result = ErrorIncorrectOption
elif skey == "log-file":
if len(value) == 0:
result = ErrorIncorrectOption
else:
config.debug.logFile = value
elif skey == "logmetrics":
config.debug.logMetrics = true
elif skey == "logmetricsinterval":
var res = 0
result = processInteger(value, res)
if result == Success:
config.debug.logMetricsInterval = res
else:
result = EmptyOption
2018-04-27 08:53:53 +00:00
proc dumpConfiguration*(): string =
## Dumps current configuration as string
let config = getConfiguration()
result = repr config
template processArgument(processor, key, value, msg: untyped) =
2018-06-20 17:27:32 +00:00
## Checks if arguments got processed successfully
var res = processor(string(key), string(value))
2018-04-27 08:53:53 +00:00
if res == Success:
result = res
2018-04-27 08:53:53 +00:00
continue
elif res == ErrorParseOption:
msg = "Error processing option '" & key & "' with value '" & value & "'."
2018-04-27 08:53:53 +00:00
result = res
break
2018-06-20 17:27:32 +00:00
elif res == ErrorIncorrectOption:
msg = "Incorrect value for option '" & key & "': '" & value & "'."
2018-06-20 17:27:32 +00:00
result = res
break
2019-01-08 11:29:56 +00:00
proc getDefaultDataDir*(): string =
when defined(windows):
"AppData" / "Roaming" / "Nimbus" / "DB"
elif defined(macosx):
"Library" / "Application Support" / "Nimbus" / "DB"
else:
".cache" / "nimbus" / "db"
2018-06-20 17:27:32 +00:00
proc initConfiguration(): NimbusConfiguration =
## Allocates and initializes `NimbusConfiguration` with default values
result = new NimbusConfiguration
## RPC defaults
result.rpc.flags = {}
result.rpc.binds = @[initTAddress("127.0.0.1:8545")]
## Network defaults
result.net.setNetwork(defaultNetwork)
2018-06-20 17:27:32 +00:00
result.net.maxPeers = 25
result.net.maxPendingPeers = 0
result.net.bindPort = 30303'u16
result.net.discPort = 30303'u16
result.net.metricsServer = false
result.net.metricsServerPort = 9093'u16
2019-01-15 15:25:14 +00:00
result.net.ident = NimbusIdent
2019-04-17 01:56:28 +00:00
result.net.nat = NatAny
result.net.protocols = defaultProtocols
2018-04-27 08:53:53 +00:00
2019-01-08 11:29:56 +00:00
const dataDir = getDefaultDataDir()
result.dataDir = getHomeDir() / dataDir
2018-11-30 03:03:30 +00:00
result.prune = PruneMode.Full
## Whisper defaults
result.shh.maxMsgSize = defaultMaxMsgSize
result.shh.powRequirement = defaultMinPow
result.shh.isLightNode = false
result.shh.bloom = fullBloom()
2018-06-20 17:27:32 +00:00
## Debug defaults
result.debug.flags = {}
result.debug.logLevel = defaultLogLevel
result.debug.logMetrics = false
result.debug.logMetricsInterval = 10
2018-06-20 17:27:32 +00:00
proc getConfiguration*(): NimbusConfiguration =
## Retreive current configuration object `NimbusConfiguration`.
if isNil(nimbusConfig):
nimbusConfig = initConfiguration()
result = nimbusConfig
2018-04-27 08:53:53 +00:00
proc getHelpString*(): string =
var logLevels: seq[string]
for level in LogLevel:
if level < enabledLogLevel:
continue
logLevels.add($level)
when defined(insecure):
let metricsServerHelp = """
--metricsServer Enable the metrics HTTP server
--metricsServerPort:<value> Metrics HTTP server port on localhost (default: 9093)"""
else:
let metricsServerHelp = ""
2018-06-20 17:27:32 +00:00
result = """
2018-04-27 08:53:53 +00:00
USAGE:
nimbus [options]
ETHEREUM OPTIONS:
--keyfile:<value> Use keyfile storage file
--datadir:<value> Base directory for all blockchain-related data
2018-11-30 03:03:30 +00:00
--prune:<value> Blockchain prune mode(full or archive)
2018-04-27 08:53:53 +00:00
NETWORKING OPTIONS:
--bootnodes:<value> Comma separated enode URLs for P2P discovery bootstrap (set v4+v5 instead for light servers)
--bootnodesv4:<value> Comma separated enode URLs for P2P v4 discovery bootstrap (light server, full nodes)
--bootnodesv5:<value> Comma separated enode URLs for P2P v5 discovery bootstrap (light server, light nodes)
--staticnodes:<value> Comma separated enode URLs to connect with
--port:<value> Network listening TCP port (default: 30303)
--discport:<value> Network listening UDP port (defaults to --port argument)$7
2018-04-27 08:53:53 +00:00
--maxpeers:<value> Maximum number of network peers (default: 25)
--maxpendpeers:<value> Maximum number of pending connection attempts (default: 0)
2019-04-17 01:56:28 +00:00
--nat:<value> NAT port mapping mechanism (any|none|upnp|pmp|<external IP>) (default: "any")
2018-04-27 08:53:53 +00:00
--nodiscover Disables the peer discovery mechanism (manual peer addition)
--v5discover Enables the experimental RLPx V5 (Topic Discovery) mechanism
--nodekey:<value> P2P node private key (as hexadecimal string)
--networkid:<value> Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby) (default: $8)
--testnet Use Ethereum Default Test Network (Ropsten)
--ropsten Use Ethereum Ropsten Test Network
2018-06-20 17:27:32 +00:00
--rinkeby Use Ethereum Rinkeby Test Network
--ident:<value> Client identifier (default is '$1')
--protocols:<value> Enable specific set of protocols (default: $4)
WHISPER OPTIONS:
--shh-maxsize:<value> Max message size accepted (default: $5)
--shh-pow:<value> Minimum POW accepted (default: $6)
--shh-light Run as Whisper light client (no outgoing messages)
2018-04-27 08:53:53 +00:00
API AND CONSOLE OPTIONS:
--rpc Enable the HTTP-RPC server
2018-06-20 17:27:32 +00:00
--rpcbind:<value> HTTP-RPC server will bind to given comma separated address:port pairs (default: 127.0.0.1:8545)
--rpcapi:<value> Enable specific set of rpc api from comma separated list(eth, shh, debug)
2018-04-27 08:53:53 +00:00
LOGGING AND DEBUGGING OPTIONS:
--log-level:<value> One of: $2 (default: $3)
--log-file:<value> Optional log file, replacing stdout
--logMetrics Enable metrics logging
--logMetricsInterval:<value> Interval at which to log metrics, in seconds (default: 10)
2018-04-27 08:53:53 +00:00
--debug Enable debug mode
--test:<value> Perform specified test
2018-06-20 17:27:32 +00:00
""" % [
NimbusIdent,
join(logLevels, ", "),
$defaultLogLevel,
strip($defaultProtocols, chars = {'{','}'}),
$defaultMaxMsgSize,
$defaultMinPow,
metricsServerHelp,
$ord(defaultNetwork)
2018-06-20 17:27:32 +00:00
]
2018-04-27 08:53:53 +00:00
when declared(os.paramCount): # not available with `--app:lib`
proc processArguments*(msg: var string): ConfigStatus =
## Process command line argument and update `NimbusConfiguration`.
let config = getConfiguration()
# At this point `config.net.bootnodes` is likely populated with network default
# bootnodes. We want to override those if at least one custom bootnode is
# specified on the command line. We temporarily set `config.net.bootNodes`
# to empty seq, and in the end restore it if no bootnodes were spricified on
# the command line.
# TODO: This is pretty hacky and it's better to refactor it to make a clear
# distinction between default and custom bootnodes.
var tempBootNodes: seq[ENode]
2018-09-25 13:30:44 +00:00
swap(tempBootNodes, config.net.bootNodes)
# The same trick is done to discPort
config.net.discPort = 0
var opt = initOptParser()
var length = 0
for kind, key, value in opt.getopt():
result = Error
case kind
of cmdArgument:
discard
of cmdLongOption, cmdShortOption:
inc(length)
case key.toLowerAscii()
of "help", "h":
msg = getHelpString()
result = Success
break
of "version", "ver", "v":
msg = NimbusVersion
result = Success
break
else:
processArgument processEthArguments, key, value, msg
processArgument processRpcArguments, key, value, msg
processArgument processNetArguments, key, value, msg
processArgument processShhArguments, key, value, msg
processArgument processDebugArguments, key, value, msg
if result != Success:
msg = "Unknown option: '" & key & "'."
break
of cmdEnd:
doAssert(false) # we're never getting this kind here
if config.net.bootNodes.len == 0:
# No custom bootnodes were specified on the command line, restore to
# previous values
swap(tempBootNodes, config.net.bootNodes)
if config.net.discPort == 0:
config.net.discPort = config.net.bindPort
2018-04-27 08:53:53 +00:00
proc processConfiguration*(pathname: string): ConfigStatus =
2018-04-27 08:53:53 +00:00
## Process configuration file `pathname` and update `NimbusConfiguration`.
result = Success