609 lines
21 KiB
Nim
609 lines
21 KiB
Nim
# beacon_chain
|
|
# Copyright (c) 2018-2024 Status Research & Development GmbH
|
|
# Licensed and distributed under either of
|
|
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
|
|
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
|
|
# at your option. This file may not be copied, modified, or distributed except according to those terms.
|
|
|
|
{.push raises: [].}
|
|
|
|
import
|
|
stew/io2, presto, metrics, metrics/chronos_httpserver,
|
|
./rpc/rest_key_management_api,
|
|
./validator_client/[
|
|
common, fallback_service, duties_service, fork_service, block_service,
|
|
doppelganger_service, attestation_service, sync_committee_service]
|
|
|
|
const
|
|
PREGENESIS_EPOCHS_COUNT = 1
|
|
|
|
declareGauge validator_client_node_counts,
|
|
"Number of connected beacon nodes and their status",
|
|
labels = ["status"]
|
|
|
|
proc initGenesis(vc: ValidatorClientRef): Future[RestGenesis] {.
|
|
async: (raises: [CancelledError]).} =
|
|
info "Initializing genesis", nodes_count = len(vc.beaconNodes)
|
|
var nodes = vc.beaconNodes
|
|
while true:
|
|
var pendingRequests: seq[Future[RestResponse[GetGenesisResponse]]]
|
|
let offlineNodes = vc.offlineNodes()
|
|
if len(offlineNodes) == 0:
|
|
let sleepDuration = 2.seconds
|
|
info "Could not resolve beacon nodes, repeating",
|
|
sleep_time = sleepDuration
|
|
await sleepAsync(sleepDuration)
|
|
for node in vc.nonameNodes():
|
|
let status = checkName(node)
|
|
node.updateStatus(status, ApiNodeFailure())
|
|
if status == RestBeaconNodeStatus.Noname:
|
|
warn "Cannot initialize beacon node", node = node, status = status
|
|
continue
|
|
|
|
for node in offlineNodes:
|
|
debug "Requesting genesis information", node = node
|
|
pendingRequests.add(node.client.getGenesis())
|
|
|
|
try:
|
|
await allFutures(pendingRequests)
|
|
except CancelledError as exc:
|
|
var pending: seq[Future[void]]
|
|
debug "Genesis information request was interrupted"
|
|
for future in pendingRequests:
|
|
if not(future.finished()):
|
|
pending.add(future.cancelAndWait())
|
|
await allFutures(pending)
|
|
raise exc
|
|
|
|
let (errorNodes, genesisList) =
|
|
block:
|
|
var gres: seq[RestGenesis]
|
|
var bres: seq[BeaconNodeServerRef]
|
|
for i in 0 ..< len(pendingRequests):
|
|
let fut = pendingRequests[i]
|
|
if fut.completed():
|
|
let resp = fut.value
|
|
if resp.status == 200:
|
|
debug "Received genesis information", endpoint = nodes[i],
|
|
genesis_time = resp.data.data.genesis_time,
|
|
genesis_fork_version = resp.data.data.genesis_fork_version,
|
|
genesis_root = resp.data.data.genesis_validators_root
|
|
gres.add(resp.data.data)
|
|
else:
|
|
debug "Received unsuccessful response code", endpoint = nodes[i],
|
|
response_code = resp.status
|
|
bres.add(nodes[i])
|
|
elif fut.failed():
|
|
let error = fut.error
|
|
debug "Could not obtain genesis information from beacon node",
|
|
endpoint = nodes[i], error_name = error.name,
|
|
reason = error.msg
|
|
bres.add(nodes[i])
|
|
else:
|
|
debug "Interrupted while requesting information from beacon node",
|
|
endpoint = nodes[i]
|
|
bres.add(nodes[i])
|
|
(bres, gres)
|
|
|
|
if len(genesisList) == 0:
|
|
let sleepDuration = 2.seconds
|
|
info "Could not obtain network genesis information from nodes, repeating",
|
|
sleep_time = sleepDuration
|
|
await sleepAsync(sleepDuration)
|
|
nodes = errorNodes
|
|
else:
|
|
# Boyer-Moore majority vote algorithm
|
|
var melem: RestGenesis
|
|
var counter = 0
|
|
for item in genesisList:
|
|
if counter == 0:
|
|
melem = item
|
|
inc(counter)
|
|
else:
|
|
if melem == item:
|
|
inc(counter)
|
|
else:
|
|
dec(counter)
|
|
return melem
|
|
|
|
proc addValidatorsFromWeb3Signer(
|
|
vc: ValidatorClientRef,
|
|
web3signerUrl: Web3SignerUrl
|
|
) {.async: (raises: [CancelledError]).} =
|
|
let res = await queryValidatorsSource(web3signerUrl)
|
|
if res.isOk():
|
|
let dynamicKeystores = res.get()
|
|
for keystore in dynamicKeystores:
|
|
vc.addValidator(keystore)
|
|
|
|
proc initValidators(
|
|
vc: ValidatorClientRef
|
|
): Future[bool] {.async: (raises: [CancelledError]).} =
|
|
info "Loading validators", validatorsDir = vc.config.validatorsDir()
|
|
for keystore in listLoadableKeystores(vc.config, vc.keystoreCache):
|
|
vc.addValidator(keystore)
|
|
|
|
let web3signerValidatorsFuts = mapIt(
|
|
vc.config.web3SignerUrls,
|
|
vc.addValidatorsFromWeb3Signer(it))
|
|
|
|
# We use `allFutures` because all failures are already reported as
|
|
# user-visible warnings in `queryValidatorsSource`.
|
|
# We don't consider them fatal because the Web3Signer may be experiencing
|
|
# a temporary hiccup that will be resolved later.
|
|
await allFutures(web3signerValidatorsFuts)
|
|
|
|
true
|
|
|
|
proc initClock(
|
|
vc: ValidatorClientRef
|
|
): Future[BeaconClock] {.
|
|
async: (raises: [CancelledError, ValidatorClientError]).} =
|
|
# This procedure performs initialization of BeaconClock using current genesis
|
|
# information. It also performs waiting for genesis.
|
|
let
|
|
res = BeaconClock.init(vc.beaconGenesis.genesis_time).valueOr:
|
|
raise (ref ValidatorClientError)(
|
|
msg: "Invalid genesis time: " & $vc.beaconGenesis.genesis_time)
|
|
currentTime = res.now()
|
|
currentSlot = currentTime.slotOrZero()
|
|
currentEpoch = currentSlot.epoch()
|
|
genesisTime = res.fromNow(Slot(0))
|
|
|
|
if genesisTime.inFuture:
|
|
info "Initializing beacon clock",
|
|
genesis_time = vc.beaconGenesis.genesis_time,
|
|
current_slot = "<n/a>", current_epoch = "<n/a>",
|
|
time_to_genesis = genesisTime.offset
|
|
else:
|
|
info "Initializing beacon clock",
|
|
genesis_time = vc.beaconGenesis.genesis_time,
|
|
current_slot = currentSlot, current_epoch = currentEpoch
|
|
res
|
|
|
|
proc initMetrics(
|
|
vc: ValidatorClientRef
|
|
): Future[bool] {.async: (raises: [CancelledError]).} =
|
|
if vc.config.metricsEnabled:
|
|
let
|
|
metricsAddress = vc.config.metricsAddress
|
|
metricsPort = vc.config.metricsPort
|
|
url = "http://" & $metricsAddress & ":" & $metricsPort & "/metrics"
|
|
info "Starting metrics HTTP server", url = url
|
|
let server =
|
|
block:
|
|
let res = MetricsHttpServerRef.new($metricsAddress, metricsPort)
|
|
if res.isErr():
|
|
error "Could not start metrics HTTP server", url = url,
|
|
error_msg = res.error()
|
|
return false
|
|
res.get()
|
|
vc.metricsServer = Opt.some(server)
|
|
try:
|
|
await server.start()
|
|
except MetricsError as exc:
|
|
error "Could not start metrics HTTP server", url = url,
|
|
error_msg = exc.msg, error_name = exc.name
|
|
return false
|
|
true
|
|
|
|
proc shutdownMetrics(vc: ValidatorClientRef) {.async: (raises: []).} =
|
|
if vc.config.metricsEnabled:
|
|
if vc.metricsServer.isSome():
|
|
info "Shutting down metrics HTTP server"
|
|
await vc.metricsServer.get().close()
|
|
|
|
proc shutdownSlashingProtection(vc: ValidatorClientRef) =
|
|
info "Closing slashing protection", path = vc.config.validatorsDir()
|
|
vc.attachedValidators[].slashingProtection.close()
|
|
|
|
proc runVCSlotLoop(
|
|
vc: ValidatorClientRef) {.async: (raises: [CancelledError]).} =
|
|
var
|
|
startTime = vc.beaconClock.now()
|
|
curSlot = startTime.slotOrZero()
|
|
nextSlot = curSlot + 1 # No earlier than GENESIS_SLOT + 1
|
|
timeToNextSlot = nextSlot.start_beacon_time() - startTime
|
|
|
|
info "Scheduling first slot action",
|
|
start_time = shortLog(startTime),
|
|
current_slot = shortLog(curSlot),
|
|
next_slot = shortLog(nextSlot),
|
|
time_to_next_slot = shortLog(timeToNextSlot)
|
|
|
|
var currentSlot = Opt.some(curSlot)
|
|
|
|
while true:
|
|
currentSlot = await vc.checkedWaitForNextSlot(currentSlot, ZeroTimeDiff,
|
|
true)
|
|
if currentSlot.isNone():
|
|
## Fatal log line should be printed by checkedWaitForNextSlot().
|
|
return
|
|
|
|
let
|
|
wallTime = vc.beaconClock.now()
|
|
wallSlot = currentSlot.get()
|
|
delay = wallTime - wallSlot.start_beacon_time()
|
|
|
|
if checkIfShouldStopAtEpoch(wallSlot, vc.config.stopAtEpoch):
|
|
return
|
|
|
|
vc.processingDelay = Opt.some(nanoseconds(delay.nanoseconds))
|
|
|
|
let
|
|
counts = vc.getNodeCounts()
|
|
# Good nodes are nodes which can be used for ALL the requests.
|
|
goodNodes = counts.data[int(RestBeaconNodeStatus.Synced)]
|
|
# Viable nodes are nodes which can be used only SOME of the requests.
|
|
viableNodes = counts.data[int(RestBeaconNodeStatus.OptSynced)] +
|
|
counts.data[int(RestBeaconNodeStatus.NotSynced)] +
|
|
counts.data[int(RestBeaconNodeStatus.Compatible)]
|
|
# Bad nodes are nodes which can't be used at all.
|
|
badNodes = counts.data[int(RestBeaconNodeStatus.Offline)] +
|
|
counts.data[int(RestBeaconNodeStatus.Online)] +
|
|
counts.data[int(RestBeaconNodeStatus.Incompatible)]
|
|
|
|
validator_client_node_counts.set(int64(goodNodes), ["good"])
|
|
validator_client_node_counts.set(int64(viableNodes), ["viable"])
|
|
validator_client_node_counts.set(int64(badNodes), ["bad"])
|
|
|
|
if len(vc.beaconNodes) > 1:
|
|
info "Slot start",
|
|
slot = shortLog(wallSlot),
|
|
epoch = shortLog(wallSlot.epoch()),
|
|
attestationIn = vc.getDurationToNextAttestation(wallSlot),
|
|
blockIn = vc.getDurationToNextBlock(wallSlot),
|
|
validators = vc.attachedValidators[].count(),
|
|
good_nodes = goodNodes, viable_nodes = viableNodes,
|
|
bad_nodes = badNodes,
|
|
delay = shortLog(delay)
|
|
else:
|
|
info "Slot start",
|
|
slot = shortLog(wallSlot),
|
|
epoch = shortLog(wallSlot.epoch()),
|
|
attestationIn = vc.getDurationToNextAttestation(wallSlot),
|
|
blockIn = vc.getDurationToNextBlock(wallSlot),
|
|
validators = vc.attachedValidators[].count(),
|
|
node_status = $vc.beaconNodes[0].status,
|
|
delay = shortLog(delay)
|
|
|
|
proc new*(
|
|
T: type ValidatorClientRef,
|
|
config: ValidatorClientConf,
|
|
rng: ref HmacDrbgContext
|
|
): ValidatorClientRef =
|
|
let beaconNodes =
|
|
block:
|
|
var servers: seq[BeaconNodeServerRef]
|
|
for index, url in config.beaconNodes.pairs():
|
|
let res = BeaconNodeServerRef.init(url, index)
|
|
if res.isErr():
|
|
warn "Unable to initialize remote beacon node",
|
|
url = $url, error = res.error()
|
|
else:
|
|
if res.get().status != RestBeaconNodeStatus.Noname:
|
|
debug "Beacon node was initialized", node = res.get()
|
|
servers.add(res.get())
|
|
let missingRoles = getMissingRoles(servers)
|
|
if len(missingRoles) != 0:
|
|
if len(servers) == 0:
|
|
fatal "Not enough beacon nodes available",
|
|
nodes_count = len(servers)
|
|
quit 1
|
|
else:
|
|
fatal "Beacon nodes do not cover all required roles",
|
|
missing_roles = $missingRoles, nodes_count = len(servers)
|
|
quit 1
|
|
servers
|
|
|
|
when declared(waitSignal):
|
|
ValidatorClientRef(
|
|
rng: rng,
|
|
config: config,
|
|
beaconNodes: beaconNodes,
|
|
graffitiBytes: config.graffiti.get(defaultGraffitiBytes()),
|
|
preGenesisEvent: newAsyncEvent(),
|
|
genesisEvent: newAsyncEvent(),
|
|
nodesAvailable: newAsyncEvent(),
|
|
forksAvailable: newAsyncEvent(),
|
|
doppelExit: newAsyncEvent(),
|
|
indicesAvailable: newAsyncEvent(),
|
|
dynamicFeeRecipientsStore: newClone(DynamicFeeRecipientsStore.init()),
|
|
sigintHandleFut: waitSignal(SIGINT),
|
|
sigtermHandleFut: waitSignal(SIGTERM),
|
|
keystoreCache: KeystoreCacheRef.init()
|
|
)
|
|
else:
|
|
ValidatorClientRef(
|
|
rng: rng,
|
|
config: config,
|
|
beaconNodes: beaconNodes,
|
|
graffitiBytes: config.graffiti.get(defaultGraffitiBytes()),
|
|
preGenesisEvent: newAsyncEvent(),
|
|
genesisEvent: newAsyncEvent(),
|
|
nodesAvailable: newAsyncEvent(),
|
|
forksAvailable: newAsyncEvent(),
|
|
indicesAvailable: newAsyncEvent(),
|
|
doppelExit: newAsyncEvent(),
|
|
dynamicFeeRecipientsStore: newClone(DynamicFeeRecipientsStore.init()),
|
|
sigintHandleFut: newFuture[void]("sigint_placeholder"),
|
|
sigtermHandleFut: newFuture[void]("sigterm_placeholder"),
|
|
keystoreCache: KeystoreCacheRef.init()
|
|
)
|
|
|
|
proc asyncInit(vc: ValidatorClientRef): Future[ValidatorClientRef] {.
|
|
async: (raises: [CancelledError, ValidatorClientError]).} =
|
|
notice "Launching validator client", version = fullVersionStr,
|
|
cmdParams = commandLineParams(),
|
|
config = vc.config,
|
|
beacon_nodes_count = len(vc.beaconNodes)
|
|
|
|
for node in vc.beaconNodes:
|
|
if node.status == RestBeaconNodeStatus.Offline:
|
|
notice "Beacon node initialized", node = node
|
|
else:
|
|
notice "Cannot initialize beacon node", node = node, status = node.status
|
|
|
|
vc.beaconGenesis = await vc.initGenesis()
|
|
info "Genesis information", genesis_time = vc.beaconGenesis.genesis_time,
|
|
genesis_fork_version = vc.beaconGenesis.genesis_fork_version,
|
|
genesis_root = vc.beaconGenesis.genesis_validators_root
|
|
|
|
vc.beaconClock = await vc.initClock()
|
|
|
|
if not(await initMetrics(vc)):
|
|
raise newException(ValidatorClientError,
|
|
"Could not initialize metrics server")
|
|
|
|
info "Initializing slashing protection", path = vc.config.validatorsDir()
|
|
|
|
let
|
|
slashingProtectionDB =
|
|
SlashingProtectionDB.init(
|
|
vc.beaconGenesis.genesis_validators_root,
|
|
vc.config.validatorsDir(), "slashing_protection")
|
|
validatorPool = newClone(ValidatorPool.init(
|
|
slashingProtectionDB, vc.config.doppelgangerDetection))
|
|
|
|
vc.attachedValidators = validatorPool
|
|
|
|
if not(await initValidators(vc)):
|
|
await vc.shutdownMetrics()
|
|
raise newException(ValidatorClientError,
|
|
"Could not initialize local validators")
|
|
|
|
let
|
|
keymanagerInitResult = initKeymanagerServer(vc.config, nil)
|
|
|
|
func getCapellaForkVersion(): Opt[Version] =
|
|
if vc.forkConfig.isNone():
|
|
return Opt.none(Version)
|
|
|
|
try:
|
|
Opt.some(vc.forkConfig.get()[ConsensusFork.Capella].version)
|
|
except KeyError:
|
|
Opt.none(Version)
|
|
|
|
func getDenebForkEpoch(): Opt[Epoch] =
|
|
if vc.forkConfig.isNone():
|
|
return Opt.none(Epoch)
|
|
|
|
try:
|
|
Opt.some(vc.forkConfig.get()[ConsensusFork.Deneb].epoch)
|
|
except KeyError:
|
|
Opt.none(Epoch)
|
|
|
|
proc getForkForEpoch(epoch: Epoch): Opt[Fork] =
|
|
if len(vc.forks) > 0:
|
|
Opt.some(vc.forkAtEpoch(epoch))
|
|
else:
|
|
Opt.none(Fork)
|
|
|
|
proc getGenesisRoot(): Eth2Digest =
|
|
vc.beaconGenesis.genesis_validators_root
|
|
|
|
try:
|
|
vc.fallbackService = await FallbackServiceRef.init(vc)
|
|
vc.forkService = await ForkServiceRef.init(vc)
|
|
vc.dutiesService = await DutiesServiceRef.init(vc)
|
|
vc.doppelgangerService = await DoppelgangerServiceRef.init(vc)
|
|
vc.attestationService = await AttestationServiceRef.init(vc)
|
|
vc.blockService = await BlockServiceRef.init(vc)
|
|
vc.syncCommitteeService = await SyncCommitteeServiceRef.init(vc)
|
|
vc.keymanagerServer = keymanagerInitResult.server
|
|
if not(isNil(vc.keymanagerServer)):
|
|
vc.keymanagerHost = newClone KeymanagerHost.init(
|
|
validatorPool,
|
|
vc.keystoreCache,
|
|
vc.rng,
|
|
keymanagerInitResult.token,
|
|
vc.config.validatorsDir,
|
|
vc.config.secretsDir,
|
|
vc.config.defaultFeeRecipient,
|
|
vc.config.suggestedGasLimit,
|
|
vc.config.defaultGraffitiBytes,
|
|
Opt.none(string),
|
|
nil,
|
|
vc.beaconClock.getBeaconTimeFn,
|
|
getCapellaForkVersion,
|
|
getDenebForkEpoch,
|
|
getForkForEpoch,
|
|
getGenesisRoot
|
|
)
|
|
except CancelledError:
|
|
debug "Initialization process interrupted"
|
|
await vc.shutdownMetrics()
|
|
vc.shutdownSlashingProtection()
|
|
return
|
|
|
|
return vc
|
|
|
|
proc runPreGenesisWaitingLoop(
|
|
vc: ValidatorClientRef
|
|
) {.async: (raises: [CancelledError]).} =
|
|
var breakLoop = false
|
|
while not(breakLoop):
|
|
let
|
|
genesisTime = vc.beaconClock.fromNow(Slot(0))
|
|
currentEpoch = vc.beaconClock.now().toSlot().slot.epoch()
|
|
|
|
if not(genesisTime.inFuture) or currentEpoch < PREGENESIS_EPOCHS_COUNT:
|
|
break
|
|
|
|
notice "Waiting for genesis",
|
|
genesis_time = vc.beaconGenesis.genesis_time,
|
|
time_to_genesis = genesisTime.offset
|
|
|
|
breakLoop =
|
|
try:
|
|
await sleepAsync(vc.beaconClock.durationToNextSlot())
|
|
false
|
|
except CancelledError as exc:
|
|
debug "Pre-genesis waiting loop was interrupted"
|
|
raise exc
|
|
|
|
if not(breakLoop):
|
|
vc.preGenesisEvent.fire()
|
|
|
|
proc runGenesisWaitingLoop(
|
|
vc: ValidatorClientRef
|
|
) {.async: (raises: [CancelledError]).} =
|
|
var breakLoop = false
|
|
while not(breakLoop):
|
|
let genesisTime = vc.beaconClock.fromNow(Slot(0))
|
|
|
|
if not(genesisTime.inFuture):
|
|
break
|
|
|
|
notice "Waiting for genesis",
|
|
genesis_time = vc.beaconGenesis.genesis_time,
|
|
time_to_genesis = genesisTime.offset
|
|
|
|
breakLoop =
|
|
try:
|
|
await sleepAsync(vc.beaconClock.durationToNextSlot())
|
|
false
|
|
except CancelledError as exc:
|
|
debug "Genesis waiting loop was interrupted"
|
|
raise exc
|
|
|
|
if not(breakLoop):
|
|
vc.genesisEvent.fire()
|
|
|
|
proc asyncRun*(
|
|
vc: ValidatorClientRef
|
|
) {.async: (raises: [ValidatorClientError]).} =
|
|
vc.fallbackService.start()
|
|
vc.forkService.start()
|
|
vc.dutiesService.start()
|
|
vc.doppelgangerService.start()
|
|
vc.attestationService.start()
|
|
vc.blockService.start()
|
|
vc.syncCommitteeService.start()
|
|
|
|
if not(isNil(vc.keymanagerServer)):
|
|
doAssert not(isNil(vc.keymanagerHost))
|
|
vc.keymanagerServer.router.installKeymanagerHandlers(vc.keymanagerHost[])
|
|
vc.keymanagerServer.start()
|
|
|
|
let doppelEventFut = vc.doppelExit.wait()
|
|
try:
|
|
# Waiting for `GENESIS - PREGENESIS_EPOCHS_COUNT` loop.
|
|
await vc.runPreGenesisWaitingLoop()
|
|
# Waiting for `GENESIS` loop.
|
|
await vc.runGenesisWaitingLoop()
|
|
# Main processing loop.
|
|
vc.runSlotLoopFut = vc.runVCSlotLoop()
|
|
vc.runKeystoreCachePruningLoopFut =
|
|
runKeystoreCachePruningLoop(vc.keystoreCache)
|
|
discard await race(vc.runSlotLoopFut, doppelEventFut)
|
|
if not(vc.runSlotLoopFut.finished()):
|
|
notice "Received shutdown event, exiting"
|
|
except CancelledError:
|
|
debug "Main loop interrupted"
|
|
|
|
await vc.shutdownMetrics()
|
|
vc.shutdownSlashingProtection()
|
|
|
|
if doppelEventFut.completed():
|
|
# Critically, database has been shut down - the rest doesn't matter, we need
|
|
# to stop as soon as possible
|
|
quitDoppelganger()
|
|
|
|
debug "Stopping main processing loop"
|
|
var pending: seq[Future[void]]
|
|
if not(isNil(vc.runSlotLoopFut)) and not(vc.runSlotLoopFut.finished()):
|
|
pending.add(vc.runSlotLoopFut.cancelAndWait())
|
|
if not(isNil(vc.runKeystoreCachePruningLoopFut)) and
|
|
not(vc.runKeystoreCachePruningLoopFut.finished()):
|
|
pending.add(vc.runKeystoreCachePruningLoopFut.cancelAndWait())
|
|
if not(doppelEventFut.finished()):
|
|
pending.add(doppelEventFut.cancelAndWait())
|
|
debug "Stopping running services"
|
|
pending.add(vc.fallbackService.stop())
|
|
pending.add(vc.forkService.stop())
|
|
pending.add(vc.dutiesService.stop())
|
|
pending.add(vc.doppelgangerService.stop())
|
|
pending.add(vc.attestationService.stop())
|
|
pending.add(vc.blockService.stop())
|
|
pending.add(vc.syncCommitteeService.stop())
|
|
if not isNil(vc.keymanagerServer):
|
|
pending.add(vc.keymanagerServer.stop())
|
|
await noCancel allFutures(pending)
|
|
|
|
template runWithSignals(vc: ValidatorClientRef, body: untyped): bool =
|
|
let future = body
|
|
|
|
try:
|
|
discard await race(future, vc.sigintHandleFut, vc.sigtermHandleFut)
|
|
except CancelledError:
|
|
discard
|
|
|
|
if future.finished():
|
|
if future.failed() or future.cancelled():
|
|
let exc = future.error
|
|
error "Validator client initialization failed", err_name = $exc.name,
|
|
err_msg = $exc.msg
|
|
var pending: seq[Future[void]]
|
|
if not(vc.sigintHandleFut.finished()):
|
|
pending.add(cancelAndWait(vc.sigintHandleFut))
|
|
if not(vc.sigtermHandleFut.finished()):
|
|
pending.add(cancelAndWait(vc.sigtermHandleFut))
|
|
await noCancel allFutures(pending)
|
|
false
|
|
else:
|
|
true
|
|
else:
|
|
let signal = if vc.sigintHandleFut.finished(): "SIGINT" else: "SIGTERM"
|
|
info "Got interrupt, trying to shutdown gracefully", signal = signal
|
|
var pending = @[cancelAndWait(future)]
|
|
if not(vc.sigintHandleFut.finished()):
|
|
pending.add(cancelAndWait(vc.sigintHandleFut))
|
|
if not(vc.sigtermHandleFut.finished()):
|
|
pending.add(cancelAndWait(vc.sigtermHandleFut))
|
|
await noCancel allFutures(pending)
|
|
false
|
|
|
|
proc runValidatorClient*(
|
|
config: ValidatorClientConf,
|
|
rng: ref HmacDrbgContext
|
|
) {.async: (raises: []).} =
|
|
let vc = ValidatorClientRef.new(config, rng)
|
|
if not vc.runWithSignals(asyncInit vc):
|
|
return
|
|
if not vc.runWithSignals(asyncRun vc):
|
|
return
|
|
|
|
programMain:
|
|
let
|
|
config = makeBannerAndConfig("Nimbus validator client " & fullVersionStr,
|
|
ValidatorClientConf)
|
|
|
|
# Single RNG instance for the application - will be seeded on construction
|
|
# and avoid using system resources (such as urandom) after that
|
|
rng = HmacDrbgContext.new()
|
|
|
|
setupFileLimits()
|
|
setupLogging(config.logLevel, config.logStdout, config.logFile)
|
|
waitFor runValidatorClient(config, rng)
|