pmtiles-swarm 0.35.1 → 0.35.2

package/CHANGELOG.md

@@ -7,6 +7,25 @@
 ### 🐞 Bug fixes
 - _...Add new stuff here..._
 
+## 0.35.2
+### ✨ Features and improvements
+
+### 🐞 Bug fixes
+- **A killed sidecar is reported with the signal that killed it.** `child.on('exit')` gives a null
+  code when a process dies by signal and puts the name in the *second* argument, which 0.35.1 did
+  not read — so the one case where the code carries no information printed `exited (code null)`
+  and withheld the word that does. It now says `killed by SIGKILL` or `killed by SIGTERM`, and
+  only mentions the OOM killer for `SIGKILL`, that being the one it cannot ask for politely. The
+  0.35.1 wording guessed at memory whatever had happened, which on a box with 122 GiB free sent
+  the reader somewhere there was nothing to find.
+- **The in-process hashing fallback says what it costs.** When libtorrent cannot build a torrent,
+  creation falls back to hashing in the node process — correct, since a torrent matters more than
+  its format, but not a smaller version of the same thing: it reads the whole archive in the
+  process that also serves tiles and the console. For a 698 GiB archive that is a console which
+  has apparently locked up, with nothing in the log joining it to the sidecar that died some time
+  earlier. The warning now names the size, says the hash is happening here, and says that fixing
+  libtorrent is worth more than waiting for it.
+
 ## 0.35.1
 ### ✨ Features and improvements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmtiles-swarm",
-  "version": "0.35.1",
+  "version": "0.35.2",
   "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/engines/libtorrent.js

@@ -247,7 +247,7 @@ export class LibtorrentEngine {
         );
       });
 
-      child.on('exit', (code) => {
+      child.on('exit', (code, signal) => {
         clearTimeout(timer);
         this.#child = null;
 
@@ -270,13 +270,24 @@ export class LibtorrentEngine {
         // left nothing in the log at all. What the operator saw instead was
         // "libtorrent sidecar is not running" once a second, for ever, with no
         // line anywhere saying when it stopped or why.
-        console.error(
-          `[libtorrent] sidecar exited (code ${code}). No stderr above this ` +
-            'means it was killed rather than failing — the OOM killer is the ' +
-            'usual reason on a node hashing or downloading a large archive.',
-        );
-
-        const error = new Error(`libtorrent sidecar exited (code ${code})`);
+        // The signal, not just the code. A process killed by one exits with a
+        // null code, so reporting the code alone said "exited (code null)" —
+        // which names the one case where the code carries no information and
+        // withholds the word that does. SIGKILL is the OOM killer or someone
+        // with a big hammer; SIGTERM is something asking politely, which for a
+        // sidecar nobody meant to stop is usually the service manager taking
+        // the whole cgroup down.
+        const how = signal ? `killed by ${signal}` : `exited with code ${code}`;
+        const why = signal
+          ? signal === 'SIGKILL'
+            ? ' Nothing asks for SIGKILL politely: on a node hashing or ' +
+              'downloading a large archive this is the OOM killer, and ' +
+              '`dmesg -T | grep -i oom` will say so outright.'
+            : ''
+          : ' No stderr above this means it failed without saying why.';
+        console.error(`[libtorrent] sidecar ${how}.${why}`);
+
+        const error = new Error(`libtorrent sidecar ${how}`);
         for (const { reject: fail } of this.#pending.values()) fail(error);
         this.#pending.clear();
 

package/src/torrent-create.js

@@ -671,7 +671,21 @@ async function buildTorrent(input, name, size, options) {
       };
     } catch (error) {
       // A torrent is more important than the format of a torrent.
-      console.warn(`[create] ${error.message}; falling back to a v1 torrent`);
+      //
+      // Said with what it costs, though, because the fallback is not a smaller
+      // version of the same thing. libtorrent hashes in its own process; this
+      // hashes in *this* one, so an archive large enough to be worth handing
+      // to libtorrent is now being read end to end by the process also serving
+      // tiles and the console — which is how a sidecar dying mid-create turns
+      // into a console that has apparently locked up, with nothing in the log
+      // connecting the two.
+      const gib = size ? ` (${(size / 1024 ** 3).toFixed(1)} GiB)` : '';
+      console.warn(
+        `[create] ${error.message}; hashing${gib} in this process instead, ` +
+          'which is slower, holds no hybrid v2 layers, and competes with ' +
+          'everything else this node is doing. Fixing whatever stopped ' +
+          'libtorrent is worth more than waiting for this.',
+      );
     }
   }