pmtiles-swarm 0.5.4 → 0.5.6

package/CHANGELOG.md

@@ -7,6 +7,32 @@
 ### 🐞 Bug fixes
 - _...Add new stuff here..._
 
+## 0.5.6
+### 🐞 Bug fixes
+- **The Pieces and Peers tabs redraw themselves.** A detail pane is filled once, the first time
+  it is opened — right for the panes describing an archive, whose name and source and trackers
+  do not change, and wrong for the two describing what is happening *now*. Pieces arrived and
+  peers came and went behind a picture taken when the tab was opened, and the only way to see
+  the current one was to close the panel and open it again, or reload the page. Those two now
+  follow the same three-second tick as the archive table. The rest stay lazy, since redrawing a
+  pane nobody is watching is requests every tick for nothing — which is why they load on demand
+  in the first place. Only while visible, and never queued behind a redraw still in flight: a
+  piece map of a large archive is a real request, and three seconds is not long enough to assume
+  the last one finished.
+
+## 0.5.5
+### 🐞 Bug fixes
+- **An archive could retire itself from head-warming and never say so.** The test for "already
+  read" was `summary.format !== 'pbf'`, and any stored summary *without* a format satisfies
+  that — so it counted as read, not vector, and therefore finished. A read that raced its
+  deadline leaves exactly such a summary behind, and from then on the archive was permanently
+  ineligible: no attempts, no log lines, and nothing to explain the silence. A summary now only
+  counts as an answer if it actually names a format.
+- **A read that never settles no longer disables warming for good.** The flag that stops two
+  reads running at once was held for the life of the process by a read that never returned, and
+  every later pass then returned at its first line — silently, for every archive. It is
+  abandoned after three times the metadata timeout, with a line saying so.
+
 ## 0.5.4
 ### ✨ Features and improvements
 - **The head-warm waits sensibly at both ends.** It used to read at the instant the node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmtiles-swarm",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "BitTorrent distribution for PMTiles map archives: create torrents, watch folders, publish and subscribe to RSS feeds, and seed through qBittorrent or an embedded client",
   "type": "module",
   "main": "src/index.js",

package/src/prewarm.js

@@ -58,6 +58,7 @@ export class HeadWarmer {
   #attempts = new Map();
   #waiting = new Set();
   #running = false;
+  #runningSince = 0;
 
   /**
    * @param {object} tiles - The tile store, for `summarize`.
@@ -94,8 +95,13 @@ export class HeadWarmer {
     // archive this can say anything about.
     if (entry.kind && entry.kind !== 'pmtiles') return false;
 
+    // A summary that names a format is one a header was actually read for.
+    // Anything else — an empty object, or one left behind by a read that raced
+    // its deadline — is not an answer, and treating it as one retired the
+    // archive permanently: no logs, no retries, nothing to explain the silence.
     const summary = entry.pmtiles;
-    if (summary && (summary.format !== 'pbf' || summary.vectorLayers)) {
+    const read = Boolean(summary?.format);
+    if (read && (summary.format !== 'pbf' || summary.vectorLayers)) {
       return false;
     }
 
@@ -137,12 +143,27 @@ export class HeadWarmer {
    * @returns {Promise<object|null>} - The entry warmed, or null.
    */
   async sweep() {
-    if (!this.enabled || this.#running) return null;
+    if (!this.enabled) return null;
+
+    if (this.#running) {
+      // A read that never settles would otherwise hold this flag for the life
+      // of the process and stop every archive from ever being warmed again —
+      // silently, since nothing logs a pass that returns at the first line.
+      const stuck = (this.#config.tiles?.metadataTimeoutMs ?? 120000) * 3;
+      if (this.#now() - this.#runningSince < stuck) return null;
+      console.warn(
+        `[warm] a read has been running for ${Math.round(
+          (this.#now() - this.#runningSince) / 1000,
+        )}s and is being abandoned`,
+      );
+      this.#running = false;
+    }
 
     const entry = this.#catalog.list().find((candidate) => this.due(candidate));
     if (!entry) return null;
 
     this.#running = true;
+    this.#runningSince = this.#now();
     try {
       // The long timeout, not the interactive one: this is a byte range from
       // an archive nobody has asked for a piece of yet.

package/src/web/index.html

@@ -729,6 +729,21 @@
       // before the node has said whether its engine applies one.
       let incompleteMarker = null;
       let activeTab = 'general';
+      /**
+       * Panes worth redrawing while they are open.
+       *
+       * A detail pane is filled once, the first time it is shown, which is
+       * right for the ones describing an archive: its name, its source, its
+       * trackers. It is wrong for these two, which describe what is happening
+       * *now* — pieces arriving and peers coming and going — and which sat
+       * frozen until the reader thought to close the panel and open it again.
+       *
+       * The rest stay as they are. Refreshing a pane nobody is watching is
+       * four requests a tick for nothing, which is why they are loaded lazily
+       * in the first place.
+       */
+      const LIVE_PANES = new Set(['pieces', 'peers']);
+      let refreshingPane = false;
 
       // What the header switch shows, so a click knows what it is toggling to.
       let speedState = null;
@@ -894,6 +909,7 @@
             ` · <b>${status.archives}</b> archives`;
           archives = list;
           renderRows();
+          refreshOpenPane();
         } catch (error) {
           $('status').textContent = `disconnected: ${error.message}`;
         }
@@ -1072,6 +1088,29 @@
           ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c],
         );
 
+      /**
+       * Redraws the open detail pane, when it is one that changes by itself.
+       *
+       * Guarded against overlapping, because a piece map of a large archive is
+       * a real request and a slow one must not have a queue of its successors
+       * behind it.
+       * @returns {void}
+       */
+      function refreshOpenPane() {
+        if (refreshingPane || !selected || !LIVE_PANES.has(activeTab)) return;
+        const pane = document.querySelector(`[data-pane="${activeTab}"]`);
+        // Only while it is on screen: a hidden pane is one the reader moved
+        // away from, and the panel may have been replaced since.
+        if (!pane || pane.hidden) return;
+
+        refreshingPane = true;
+        Promise.resolve(fillPane(activeTab, selected))
+          .catch(() => {})
+          .finally(() => {
+            refreshingPane = false;
+          });
+      }
+
       /**
        * Fills one detail tab, the first time it is opened.
        * @param {string} name - Which pane.