Beacon sync maint update and code cosmetics (#3847)

* Make beacon sync `start()`/`stop()` more robust

why
  Make it resilient against `stop()` without `start()`, etc.

* Rename `Buddy` in object names to `Peer` or `SyncPeer`

* Introduce beacon syncer stand-by mode

why
  It is needed for holding back auto-magic activation. This allows to
  maintain some basic functionality but not doing anything. I will be
  useful with other sync protocols as `snap`. Still metrics are working.

  While `snap` is active, the beacon sync must hold back. It can
  resume when `snap` has terminated.

Author: mjfh

execution_chain/sync/beacon.nim

@@ -42,16 +42,16 @@ proc runDaemon(ctx: BeaconCtxRef): Future[Duration] {.async: (raises: []).} =
 proc runTicker(ctx: BeaconCtxRef) =
   worker.runTicker(ctx, "Ticker")
 
-proc runStart(buddy: BeaconBuddyRef): bool =
+proc runStart(buddy: BeaconPeerRef): bool =
   worker.start(buddy, "Start")
 
-proc runStop(buddy: BeaconBuddyRef) =
+proc runStop(buddy: BeaconPeerRef) =
   worker.stop(buddy, "Stop")
 
-proc runPool(buddy: BeaconBuddyRef; last: bool; laps: int): bool =
+proc runPool(buddy: BeaconPeerRef; last: bool; laps: int): bool =
   worker.runPool(buddy, last, laps, "SyncMode")
 
-proc runPeer(buddy: BeaconBuddyRef): Future[Duration] {.async: (raises: []).} =
+proc runPeer(buddy: BeaconPeerRef): Future[Duration] {.async: (raises: []).} =
   let rank = buddy.classifyForFetching()
   return worker.runPeer(buddy, rank, "Peer")
 
@@ -75,6 +75,7 @@ proc config*(
     ethNode: EthereumNode;
     chain: ForkedChainRef;
     maxPeers: int;
+    standByMode = false;
       ) =
   ## Complete `BeaconSyncRef` descriptor initialisation.
   ##
@@ -84,6 +85,8 @@ proc config*(
   doAssert desc.ctx.isNil # This can only run once
   desc.initSync(ethNode, maxPeers)
   desc.ctx.pool.chain = chain
+  if standByMode:
+    desc.ctx.pool.syncState = SyncState.standByMode
 
   if not desc.lazyConfigHook.isNil:
     desc.lazyConfigHook(desc)
@@ -99,13 +102,23 @@ proc configTarget*(desc: BeaconSyncRef; hex: string; isFinal: bool): bool =
     discard
   # false
 
+
+proc activate*(desc: BeaconSyncRef) =
+  ## Clear stand-by mode (if any)
+  doAssert not desc.ctx.isNil
+  if desc.ctx.pool.syncState == SyncState.standByMode:
+    desc.ctx.pool.syncState = SyncState.idle
+
 proc start*(desc: BeaconSyncRef): bool =
   doAssert not desc.ctx.isNil
-  desc.startSync()
+  if not desc.isRunning and desc.startSync():
+    return true
+  # false
 
 proc stop*(desc: BeaconSyncRef) {.async.} =
   doAssert not desc.ctx.isNil
-  await desc.stopSync()
+  if desc.isRunning:
+    await desc.stopSync()
 
 # ------------------------------------------------------------------------------
 # End

execution_chain/sync/beacon/beacon_desc.nim

@@ -21,7 +21,7 @@ type
   BeaconSyncConfigHook* = proc(desc: BeaconSyncRef) {.gcsafe, raises: [].}
     ## Conditional configuration request hook
 
-  BeaconSyncRef* = ref object of RunnerSyncRef[BeaconCtxData,BeaconBuddyData]
+  BeaconSyncRef* = ref object of RunnerSyncRef[BeaconCtxData,BeaconPeerData]
     ## Instance descriptor, extends scheduler object
     lazyConfigHook*: BeaconSyncConfigHook
 

execution_chain/sync/beacon/worker.nim

@@ -33,7 +33,7 @@ proc release*(ctx: BeaconCtxRef; info: static[string]) =
   ctx.destroyServices()
 
 
-proc start*(buddy: BeaconBuddyRef; info: static[string]): bool =
+proc start*(buddy: BeaconPeerRef; info: static[string]): bool =
   ## Initialise worker peer
   let
     peer = buddy.peer
@@ -43,20 +43,20 @@ proc start*(buddy: BeaconBuddyRef; info: static[string]): bool =
     if not ctx.hibernate: debug info & ": useless peer already tried", peer
     return false
 
-  if not buddy.startBuddy():
+  if not buddy.startSyncPeer():
     if not ctx.hibernate: debug info & ": failed", peer
     return false
 
   if not ctx.hibernate: debug info & ": new peer",
     peer, nSyncPeers=ctx.nSyncPeers()
   true
 
-proc stop*(buddy: BeaconBuddyRef; info: static[string]) =
+proc stop*(buddy: BeaconPeerRef; info: static[string]) =
   ## Clean up this peer
   if not buddy.ctx.hibernate: debug info & ": release peer", peer=buddy.peer,
     thPut=buddy.only.thPutStats.toMeanVar.toStr,
     nSyncPeers=(buddy.ctx.nSyncPeers()-1), state=($buddy.syncState)
-  buddy.stopBuddy()
+  buddy.stopSyncPeer()
 
 # ------------------------------------------------------------------------------
 # Public functions
@@ -105,7 +105,7 @@ template runDaemon*(ctx: BeaconCtxRef; info: static[string]): Duration =
 
 
 proc runPool*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     last: bool;
     laps: int;
     info: static[string];
@@ -130,7 +130,7 @@ proc runPool*(
 
 
 template runPeer*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     rank: PeerRanking;
     info: static[string];
       ): Duration =
@@ -203,6 +203,10 @@ template runPeer*(
         bodyRc = workerIdleLongWaitInterval
       break body
 
+    elif buddy.ctx.pool.syncState == SyncState.standByMode:
+      bodyRc = workerIdleLongWaitInterval
+      break body
+
     # Idle sleep unless there is something to do
     if not buddy.somethingToCollectOrUnstage():
       bodyRc = workerIdleWaitInterval

execution_chain/sync/beacon/worker/blocks.nim

@@ -36,7 +36,7 @@ proc toStrIfAvail(bn: BlockNumber; ctx: BeaconCtxRef): string =
 # Public functions
 # ------------------------------------------------------------------------------
 
-func blocksCollectOk*(buddy: BeaconBuddyRef): bool =
+func blocksCollectOk*(buddy: BeaconPeerRef): bool =
   ## Check whether body records can be fetched and imported or stored
   ## on the `staged` queue.
   ##
@@ -49,7 +49,7 @@ func blocksCollectOk*(buddy: BeaconBuddyRef): bool =
 
 
 template blocksCollect*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     info: static[string]) =
   ## Async/template
   ##
@@ -136,7 +136,7 @@ template blocksCollect*(
         if ctx.subState.topNum < lastBn:
           ctx.blocksUnprocAppend(ctx.subState.topNum + 1, lastBn)
 
-        # Buddy might have been cancelled while importing blocks.
+        # Sync peer might have been cancelled while importing blocks.
         if buddy.ctrl.stopped or ctx.poolMode:
           break fetchBlocksBody                      # done, exit this block
 
@@ -207,7 +207,7 @@ template blocksCollect*(
 
 # --------------
 
-proc blocksUnstageOk*(buddy: BeaconBuddyRef): bool =
+proc blocksUnstageOk*(buddy: BeaconPeerRef): bool =
   ## Check whether import processing is possible
   ##
   let ctx = buddy.ctx
@@ -216,7 +216,7 @@ proc blocksUnstageOk*(buddy: BeaconBuddyRef): bool =
 
 
 template blocksUnstage*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     info: static[string];
       ): bool =
   ## Async/template

execution_chain/sync/beacon/worker/blocks/blocks_blocks.nim

@@ -40,7 +40,7 @@ func toStr(e: BeaconError): string =
 # ------------------------------------------------------------------------------
 
 template blocksFetchCheckImpl(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     iv: BnRange;
     info: static[string];
       ): Opt[seq[EthBlock]] =
@@ -136,7 +136,7 @@ template blocksFetchCheckImpl(
 # ------------------------------------------------------------------------------
 
 template blocksFetch*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     num: uint;
     info: static[string];
       ): Opt[seq[EthBlock]] =
@@ -180,7 +180,7 @@ template blocksFetch*(
 
 
 template blocksImport*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     blocks: seq[EthBlock];
     peerID: Hash;
     info: static[string];

execution_chain/sync/beacon/worker/blocks/blocks_fetch.nim

@@ -23,7 +23,7 @@ import
 # -----------------------------------------------------------------------------
 
 proc maybeSlowPeerError(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     elapsed: Duration;
     hash: Hash32;
       ): bool =
@@ -32,7 +32,7 @@ proc maybeSlowPeerError(
     buddy.bdyFetchRegisterError(slowPeer=true)
 
     # Do not repeat the same time-consuming failed request
-    buddy.only.failedReq = BuddyFirstFetchReq(
+    buddy.only.failedReq = BcPeerFirstFetchReq(
       state:     SyncState.blocks,
       blockHash: hash)
 
@@ -41,8 +41,8 @@ proc maybeSlowPeerError(
   # false
 
 
-proc getBlockBodies(
-    buddy: BeaconBuddyRef;
+proc getBlockBodies*(
+    buddy: BeaconPeerRef;
     req: BlockBodiesRequest;
       ): Future[Result[FetchBodiesData,BeaconError]]
       {.async: (raises: []).} =
@@ -77,7 +77,7 @@ proc getBlockBodies(
 # ------------------------------------------------------------------------------
 
 template fetchBodies*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     request: BlockBodiesRequest;
     info: static[string];
       ): Opt[seq[BlockBody]] =

execution_chain/sync/beacon/worker/blocks/blocks_helpers.nim

@@ -19,11 +19,11 @@ import
 # Public functions
 # ------------------------------------------------------------------------------
 
-func blkErrors*(buddy: BeaconBuddyRef): string =
+func blkErrors*(buddy: BeaconPeerRef): string =
   $buddy.nErrors.fetch.bdy & "/" & $buddy.nErrors.apply.blk
 
 proc bdyFetchRegisterError*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     slowPeer = false;
     forceZombie = false) =
   buddy.nErrors.fetch.bdy.inc
@@ -45,20 +45,20 @@ func blkSessionStopped*(ctx: BeaconCtxRef): bool =
   ctx.poolMode or
   ctx.pool.syncState != SyncState.blocks
 
-func blkThroughput*(buddy: BeaconBuddyRef): string =
+func blkThroughput*(buddy: BeaconPeerRef): string =
   ## Print throuhput sratistics
   buddy.only.thPutStats.blk.toMeanVar.toStr
 
 # -------------
 
 proc blkNoSampleSize*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     elapsed: chronos.Duration;
       ) =
   discard buddy.only.thPutStats.blk.bpsSample(elapsed, 0)
 
 proc blkSampleSize*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     elapsed: chronos.Duration;
     size: int;
       ): uint =

execution_chain/sync/beacon/worker/blocks/blocks_import.nim

@@ -21,7 +21,7 @@ import
 # ------------------------------------------------------------------------------
 
 proc importBlock*(
-    buddy: BeaconBuddyRef;
+    buddy: BeaconPeerRef;
     blk: EthBlock;
     effPeerID: Hash;
       ): Future[Result[Duration,BeaconError]]

execution_chain/sync/beacon/worker/classify.nim

@@ -17,7 +17,7 @@ import
 # Public functions
 # ------------------------------------------------------------------------------
 
-func somethingToCollectOrUnstage*(buddy: BeaconBuddyRef): bool =
+func somethingToCollectOrUnstage*(buddy: BeaconPeerRef): bool =
   if buddy.ctx.hibernate:                        # not activated yet?
     return false
   if buddy.headersCollectOk() or                 # something on TODO list
@@ -28,7 +28,7 @@ func somethingToCollectOrUnstage*(buddy: BeaconBuddyRef): bool =
   false
 
 
-func classifyForFetching*(buddy: BeaconBuddyRef): PeerRanking =
+func classifyForFetching*(buddy: BeaconPeerRef): PeerRanking =
   ## Rank and classify peers by whether they should be used for fetching
   ## data.
   ##
@@ -46,7 +46,7 @@ func classifyForFetching*(buddy: BeaconBuddyRef): PeerRanking =
     if buddy.ctx.nSyncPeers() <= headersStagedQueueLengthMax + 1:
       return (qSlotsAvail, -1)
 
-    template hdr(b: BeaconBuddyRef): StatsCollect =
+    template hdr(b: BeaconPeerRef): StatsCollect =
       b.only.thPutStats.hdr
 
     # Are there throughput data available for this peer (aka buddy), at all?
@@ -76,7 +76,7 @@ func classifyForFetching*(buddy: BeaconBuddyRef): PeerRanking =
     if buddy.ctx.nSyncPeers() <= blocksStagedQueueLengthMax + 1:
       return (qSlotsAvail, -1)
 
-    template blk(b: BeaconBuddyRef): StatsCollect =
+    template blk(b: BeaconPeerRef): StatsCollect =
       b.only.thPutStats.blk
 
     if buddy.blk.samples == 0:

execution_chain/sync/beacon/worker/headers.nim

@@ -36,7 +36,7 @@ proc nUnprocStr(ctx: BeaconCtxRef): string =
 # Public functions
 # ------------------------------------------------------------------------------
 
-func headersCollectOk*(buddy: BeaconBuddyRef): bool =
+func headersCollectOk*(buddy: BeaconPeerRef): bool =
   ## Helper for `worker.nim`, etc.
   if buddy.ctrl.running:
     let ctx = buddy.ctx
@@ -46,7 +46,7 @@ func headersCollectOk*(buddy: BeaconBuddyRef): bool =
   false
 
 
-template headersCollect*(buddy: BeaconBuddyRef; info: static[string]) =
+template headersCollect*(buddy: BeaconPeerRef; info: static[string]) =
   ## Async/template
   ##
   ## Collect headers and either stash them on the header chain cache directly,
@@ -213,14 +213,14 @@ template headersCollect*(buddy: BeaconBuddyRef; info: static[string]) =
 
 # --------------
 
-proc headersUnstageOk*(buddy: BeaconBuddyRef): bool =
+proc headersUnstageOk*(buddy: BeaconPeerRef): bool =
   ## Check whether import processing is possible
   ##
   let ctx = buddy.ctx
   not ctx.poolMode and
   0 < ctx.hdr.staged.len
 
-proc headersUnstage*(buddy: BeaconBuddyRef; info: static[string]): bool =
+proc headersUnstage*(buddy: BeaconPeerRef; info: static[string]): bool =
   ## Store headers from the `staged` queue onto the header chain cache.
   ##
   ## The function returns `false` if the caller should make sure to allow