@yetech/estra7ah 3.3.0 → 3.3.2

package/dist/estra7ah.js

@@ -36,6 +36,166 @@ function getRunner() {
   throw new Error("Unsupported platform");
 }
 
+// The VPS caps throughput per TCP connection (~2.5 MB/s), not in total, so
+// pulling the binary over several range requests at once is ~N times faster.
+const PARALLEL_CHUNKS = 6;
+
+function downloadRange(url, fd, start, end, progressBar, attempt = 0) {
+  return axios({
+    method: "get",
+    url,
+    responseType: "stream",
+    headers: { Range: `bytes=${start}-${end}` },
+    timeout: 0,
+  })
+    .then(
+      (response) =>
+        new Promise((resolve, reject) => {
+          // A 200 means the server (or a proxy on this plain-HTTP route) ignored
+          // the Range header and is sending the whole file: writing that at six
+          // different offsets corrupts the binary. Bail out to single-stream.
+          if (response.status !== 206) {
+            response.data.destroy();
+            return reject({ noRangeSupport: true });
+          }
+          let position = start;
+          // With timeout: 0 a dead connection would hang the update forever
+          // (progress stuck at 0%). Kill the stream if no data arrives for 30s
+          // so the retry/fallback path can take over.
+          let watchdog;
+          const resetWatchdog = () => {
+            clearTimeout(watchdog);
+            watchdog = setTimeout(() => {
+              response.data.destroy(new Error("download stalled: no data for 30s"));
+            }, 30000);
+          };
+          resetWatchdog();
+          response.data.on("close", () => clearTimeout(watchdog));
+          response.data.on("data", (chunk) => {
+            resetWatchdog();
+            fs.writeSync(fd, chunk, 0, chunk.length, position);
+            position += chunk.length;
+            progressBar.tick(chunk.length);
+          });
+          response.data.on("end", () => {
+            // "end" also fires on some premature disconnects; an incomplete
+            // chunk must be retried, never treated as success.
+            if (position !== end + 1) {
+              return reject({ err: new Error(`chunk ended at ${position}, expected ${end + 1}`), position });
+            }
+            resolve(position);
+          });
+          response.data.on("aborted", () => reject({ err: new Error("connection aborted"), position }));
+          response.data.on("error", (err) => reject({ err, position }));
+        })
+    )
+    .catch((failure) => {
+      if (failure && failure.noRangeSupport) throw failure;
+      const resumeAt = failure.position || start;
+      if (attempt < 2) return downloadRange(url, fd, resumeAt, end, progressBar, attempt + 1);
+      throw failure.err || failure;
+    });
+}
+
+async function downloadFileFast(url, destPath) {
+  let totalLength = 0;
+  try {
+    const head = await axios.head(url, { timeout: 10000 });
+    if ((head.headers["accept-ranges"] || "").includes("bytes")) {
+      totalLength = parseInt(head.headers["content-length"], 10) || 0;
+    }
+  } catch (error) {
+    // fall through to single-stream download
+  }
+
+  if (!totalLength) return downloadFileStream(url, destPath);
+
+  const progressBar = new ProgressBar("Downloading [:bar] :percent :etas", {
+    width: 40,
+    complete: "=",
+    incomplete: " ",
+    total: totalLength,
+  });
+
+  // Download to a temp file so a failed/interrupted update never corrupts
+  // the runner binary we already have.
+  const tmpPath = `${destPath}.download`;
+  const fd = fs.openSync(tmpPath, "w");
+  try {
+    fs.ftruncateSync(fd, totalLength);
+    const chunkSize = Math.ceil(totalLength / PARALLEL_CHUNKS);
+    const jobs = [];
+    for (let start = 0; start < totalLength; start += chunkSize) {
+      const end = Math.min(start + chunkSize - 1, totalLength - 1);
+      jobs.push(downloadRange(url, fd, start, end, progressBar));
+    }
+    await Promise.all(jobs);
+  } catch (error) {
+    fs.closeSync(fd);
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch (e) {}
+    if (error && error.noRangeSupport) return downloadFileStream(url, destPath);
+    throw error;
+  }
+  fs.closeSync(fd);
+  if (fs.statSync(tmpPath).size !== totalLength) {
+    fs.unlinkSync(tmpPath);
+    throw new Error("downloaded size does not match content-length");
+  }
+  fs.renameSync(tmpPath, destPath);
+}
+
+function downloadFileStream(url, destPath) {
+  return axios({ method: "get", url, responseType: "stream" }).then((response) => {
+    const totalLength = parseInt(response.headers["content-length"], 10);
+    const progressBar = totalLength
+      ? new ProgressBar("Downloading [:bar] :percent :etas", {
+          width: 40,
+          complete: "=",
+          incomplete: " ",
+          total: totalLength,
+        })
+      : null;
+    const tmpPath = `${destPath}.download`;
+    const writer = fs.createWriteStream(tmpPath);
+    return new Promise((resolve, reject) => {
+      let watchdog;
+      const fail = (err) => {
+        clearTimeout(watchdog);
+        writer.destroy();
+        try {
+          fs.unlinkSync(tmpPath);
+        } catch (e) {}
+        reject(err);
+      };
+      const resetWatchdog = () => {
+        clearTimeout(watchdog);
+        watchdog = setTimeout(() => {
+          response.data.destroy(new Error("download stalled: no data for 30s"));
+        }, 30000);
+      };
+      resetWatchdog();
+      response.data.on("data", (chunk) => {
+        resetWatchdog();
+        if (progressBar) progressBar.tick(chunk.length);
+      });
+      writer.on("error", fail);
+      writer.on("finish", () => {
+        clearTimeout(watchdog);
+        if (totalLength && fs.statSync(tmpPath).size !== totalLength) {
+          return fail(new Error("downloaded size does not match content-length"));
+        }
+        fs.renameSync(tmpPath, destPath);
+        resolve();
+      });
+      response.data.on("aborted", () => fail(new Error("connection aborted")));
+      response.data.on("error", fail);
+      response.data.pipe(writer);
+    });
+  });
+}
+
 // Download the runner executable
 async function downloadRunner() {
   let version = null;
@@ -60,32 +220,14 @@ async function downloadRunner() {
     const runnerPath = `${DIR_NAME}/${getRunner()}`;
 
     try {
-      const response = await axios({
-        method: "get",
-        url: serverFile,
-        responseType: "stream",
-      });
-
-      const totalLength = parseInt(response.headers["content-length"], 10);
-      const progressBar = new ProgressBar("Downloading [:bar] :percent :etas", {
-        width: 40,
-        complete: "=",
-        incomplete: " ",
-        total: totalLength,
-      });
-
-      const writer = fs.createWriteStream(runnerPath);
-
-      return new Promise((resolve, reject) => {
-        response.data.on("data", (chunk) => progressBar.tick(chunk.length));
-        writer.on("error", reject);
-        writer.on("finish", () => {
-          fs.writeFileSync(versionFilePath, version);
-          console.log("** Finished DOWNLOADING NEW RUNNER VERSION **");
-          resolve();
-        });
-        response.data.pipe(writer);
-      });
+      try {
+        await downloadFileFast(serverFile, runnerPath);
+      } catch (error) {
+        console.error("Parallel download failed, retrying with a single stream:", error.message);
+        await downloadFileStream(serverFile, runnerPath);
+      }
+      fs.writeFileSync(versionFilePath, version);
+      console.log("** Finished DOWNLOADING NEW RUNNER VERSION **");
     } catch (error) {
       console.error("Error downloading runner:", error.message);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yetech/estra7ah",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Estra7ah Manager",
   "author": "Abdullah Al-taheri",
   "keywords": [