Fix idle range completion scan

lib/replicator.js

@@ -285,6 +285,10 @@ class RangeRequest extends Attachable {
       this.ranges[rangeIndex] = h
     }
 
+    if (!this.resolved && this.replicator._updatesRunning) {
+      this.replicator._updatesQueued = true
+    }
+
     if (this.end === -1) {
       this.replicator._alwaysLatestBlock--
     }
@@ -1541,8 +1545,8 @@ class Peer {
   }
 
   _requestSeek(s) {
-    // if replicator is updating the seeks etc, bail and wait for it to drain
-    if (this.replicator._updatesPending > 0) return false
+    // if replicator is updating the seeks, bail and wait for it to drain
+    if (this.replicator._updatingSeeks) return false
     if (this.replicator.pushOnly) return false
 
     const { length, fork } = this.core.state
@@ -2028,7 +2032,9 @@ module.exports = class Replicator {
     this._hadPeers = false
     this._active = 0
     this._ifAvailable = 0
-    this._updatesPending = 0
+    this._updatingSeeks = false
+    this._updatesRunning = false
+    this._updatesQueued = false
     this._applyingReorg = null
     this._manifestPeer = null
     this._notDownloadingLinger = notDownloadingLinger
@@ -2614,55 +2620,117 @@ module.exports = class Replicator {
     }
   }
 
+  _updateRanges(index, limit) {
+    index = Math.min(index, this._ranges.length - 1)
+
+    let checked = 0
+    let resolved = 0
+    let updateAll = false
+    let remaining = Math.min(limit, this._ranges.length)
+
+    while (remaining-- > 0 && this._ranges.length > 0) {
+      if (index >= this._ranges.length) index = 0
+
+      const r = this._ranges[index]
+
+      clampRange(this.core, r)
+      checked++
+
+      if (r.end !== -1 && r.start >= r.end) {
+        this._resolveRangeRequest(r)
+        resolved++
+        // Crossing into the capped window exposes another range to peer scheduling.
+        if (this._ranges.length === MAX_RANGES) updateAll = true
+      } else {
+        index++
+      }
+    }
+
+    index = this._ranges.length === 0 ? 0 : index % this._ranges.length
+
+    return { checked, resolved, index, updateAll }
+  }
+
   // "slow" updates here - async but not allowed to ever throw
   async _updateNonPrimary(updateAll) {
-    // Check if running, if so skip it and the running one will issue another update for us (debounce)
-    while (++this._updatesPending === 1) {
-      let len = Math.min(MAX_RANGES, this._ranges.length)
+    this._updatesQueued = true
+    if (this._updatesRunning) {
+      if (this._inflight.idle || updateAll) this.queueUpdateAll()
+      return
+    }
 
-      for (let i = 0; i < len; i++) {
-        const r = this._ranges[i]
+    this._updatesRunning = true
 
-        clampRange(this.core, r)
+    while (this._updatesQueued) {
+      this._updatesQueued = false
 
-        if (r.end !== -1 && r.start >= r.end) {
-          this._resolveRangeRequest(r)
-          i--
-          if (len > this._ranges.length) len--
-          if (this._ranges.length === MAX_RANGES) updateAll = true
-        }
-      }
+      let checkedSinceResolve = 0
+      let rangeIndex = 0
+      const drain = this._inflight.idle || updateAll
+      const checkedSeeks = new Set()
 
-      for (let i = 0; i < this._seeks.length; i++) {
-        const s = this._seeks[i]
+      while (true) {
+        const limit = Math.min(MAX_RANGES, this._ranges.length - checkedSinceResolve)
+        const {
+          checked,
+          resolved,
+          index,
+          updateAll: resultUpdateAll
+        } = this._updateRanges(rangeIndex, limit)
+        rangeIndex = index
 
-        let err = null
-        let res = null
+        if (resultUpdateAll) updateAll = true
 
-        try {
-          res = await s.seeker.update()
-        } catch (error) {
-          err = error
-        }
+        if (resolved > 0) checkedSinceResolve = 0
+        else checkedSinceResolve += checked
+
+        const continueRanges = checked > 0 && checkedSinceResolve < this._ranges.length && drain
+
+        this._updatingSeeks = true
+
+        let checkedSeek = false
+        for (const s of this._seeks.slice()) {
+          if (checkedSeeks.has(s) || !this._seeks.includes(s)) continue
+          checkedSeeks.add(s)
+          checkedSeek = true
+
+          let err = null
+          let res = null
+
+          try {
+            res = await s.seeker.update()
+          } catch (error) {
+            err = error
+          }
 
-        if (!res && !err) continue
+          const seekIndex = this._seeks.indexOf(s)
+          if (seekIndex === -1 || (!res && !err)) continue
 
-        if (i < this._seeks.length - 1) this._seeks[i] = this._seeks.pop()
-        else this._seeks.pop()
+          const h = this._seeks.pop()
+          if (h !== s) this._seeks[seekIndex] = h
 
-        i--
+          if (err) s.reject(err)
+          else s.resolve(res)
+        }
+
+        this._updatingSeeks = false
+
+        if (
+          (!continueRanges || (checkedSeek && this._seeks.length > 0)) &&
+          (this._inflight.idle || updateAll)
+        ) {
+          this.queueUpdateAll()
+        }
+        if (!continueRanges) break
 
-        if (err) s.reject(err)
-        else s.resolve(res)
+        await yieldToLoop()
+        if (this.destroyed) break
       }
 
-      // No additional updates scheduled - break
-      if (--this._updatesPending === 0) break
-      // Debounce the additional updates - continue
-      this._updatesPending = 0
+      if (this.destroyed) break
     }
 
-    if (this._inflight.idle || updateAll) this.queueUpdateAll()
+    this._updatesRunning = false
   }
 
   _clearRequest(peer, req) {
@@ -3398,6 +3466,10 @@ function incrementRx(stats1, stats2) {
 
 function noop() {}
 
+function yieldToLoop() {
+  return new Promise((resolve) => setImmediate(resolve))
+}
+
 function backoff(times) {
   const sleep = times < 2 ? 200 : times < 5 ? 500 : times < 40 ? 1000 : 5000
   return new Promise((resolve) => setTimeout(resolve, sleep))