TODO: Axios uses xhr instead of http backend. Very unstable hacky solution here as backup.

Author: Eskaan

package.json

@@ -37,7 +37,7 @@
     "lint": "eslint .",
     "napi-build": "cd napi && npm run build && node ../scripts/moveNapi.js",
     "nsfw-build": "cd node_modules/nsfw && node-gyp build  && cd ../.. && node scripts/moveNsfw.js",
-    "start-electron:dev": "cross-env-shell NODE_ENV=development APP_TYPE=electron BROWSER=none wait-on http://localhost:8080 -i 2000 && electron .",
+    "start-electron:dev": "cross-env-shell NODE_ENV=development APP_TYPE=electron wait-on http://localhost:8080 -i 2000 && electron .",
     "start-electron:prod": "electron .",
     "start-web:dev": "cross-env-shell REACT_APP_RELEASE_TYPE=setup webpack serve --hot --mode development",
     "build-web:setup": "cross-env-shell REACT_APP_RELEASE_TYPE=setup webpack --mode production",

public/downloadFile.js

@@ -0,0 +1,176 @@
+import makeDir from 'make-dir';
+import fss from 'fs';
+import axios from 'axios';
+import pMap from 'p-map';
+import path from 'path';
+import adapter from 'axios/lib/adapters/http';
+
+const fs = fss.promises;
+
+function getUri(url) {
+  return new URL(url).href;
+}
+
+export const downloadInstanceFiles = async (
+  mainWindow,
+  arr,
+  updatePercentage,
+  threads = 4
+) => {
+  let downloaded = 0;
+  await pMap(
+    arr,
+    async item => {
+      let counter = 0;
+      let res = false;
+      if (!item.path || !item.url) {
+        console.warn('Skipping', item);
+        return;
+      }
+      do {
+        counter += 1;
+        if (counter !== 1) {
+          await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+
+        try {
+          res = await downloadFileInstance(
+            item.path,
+            item.url,
+            item.sha1,
+            item.legacyPath
+          );
+        } catch {
+          // Do nothing
+        }
+      } while (!res && counter < 3);
+      downloaded += 1;
+      if (
+        updatePercentage &&
+        (downloaded % 5 === 0 || downloaded === arr.length)
+      ) {
+        mainWindow.webContents.send(
+          'download-instance-files-progress',
+          downloaded
+        );
+      }
+    },
+    { concurrency: threads }
+  );
+};
+
+const computeFileHash = (filePath, algorithm = 'sha1') =>
+  new Promise((resolve, reject) => {
+    const hash = crypto.createHash(algorithm);
+    fs.createReadStream(filePath)
+      .on('data', data => hash.update(data))
+      .on('end', () => resolve(hash.digest('hex')))
+      .on('error', reject);
+  });
+
+const downloadFileInstance = async (fileName, url, sha1, legacyPath) => {
+  let encodedUrl;
+  try {
+    const filePath = path.dirname(fileName);
+    try {
+      await fs.access(fileName);
+      if (legacyPath) await fs.access(legacyPath);
+      const checksum = await computeFileHash(fileName);
+      const legacyChecksum = legacyPath && (await computeFileHash(legacyPath));
+      if (checksum === sha1 && (!legacyPath || legacyChecksum === sha1)) {
+        return true;
+      }
+    } catch {
+      await makeDir(filePath);
+      if (legacyPath) await makeDir(path.dirname(legacyPath));
+    }
+
+    encodedUrl = getUri(url);
+
+    const { data } = await axios.get(encodedUrl, {
+      responseType: 'stream',
+      responseEncoding: null,
+      adapter,
+      timeout: 60000 * 20
+    });
+
+    const wStream = fss.createWriteStream(fileName, {
+      encoding: null
+    });
+
+    data.pipe(wStream);
+    let wStreamLegacy;
+    if (legacyPath) {
+      wStreamLegacy = fss.createWriteStream(legacyPath, {
+        encoding: null
+      });
+      data.pipe(wStreamLegacy);
+    }
+
+    await new Promise((resolve, reject) => {
+      data.on('error', err => {
+        console.error(err);
+        reject(err);
+      });
+
+      data.on('end', () => {
+        wStream.end();
+        wStream.close();
+        if (legacyPath) {
+          wStreamLegacy.end();
+          wStreamLegacy.close();
+        }
+        resolve();
+      });
+    });
+    return true;
+  } catch (e) {
+    console.error(
+      `Error while downloading <${url} | ${encodedUrl}> to <${fileName}> --> ${e.message}`
+    );
+    return false;
+  }
+};
+
+export const downloadFile = async (mainWindow, fileName, url, onProgress) => {
+  await makeDir(path.dirname(fileName));
+
+  const encodedUrl = getUri(url);
+
+  const { data, headers } = await axios.get(encodedUrl, {
+    responseType: 'stream',
+    responseEncoding: null,
+    adapter,
+    timeout: 60000 * 20
+  });
+
+  const out = fss.createWriteStream(fileName, { encoding: null });
+  data.pipe(out);
+
+  // Save variable to know progress
+  let receivedBytes = 0;
+  const totalBytes = parseInt(headers['content-length'], 10);
+
+  data.on('data', chunk => {
+    // Update the received bytes
+    receivedBytes += chunk.length;
+    if (onProgress) {
+      mainWindow.webContents.send(
+        'download-file-progress',
+        parseInt(((receivedBytes * 100) / totalBytes).toFixed(1), 10)
+      );
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    data.on('end', () => {
+      out.end();
+      out.close();
+      resolve();
+    });
+
+    data.on('error', () => {
+      reject();
+    });
+  });
+};

public/electron.js

@@ -35,6 +35,7 @@ let tray;
 let watcher;
 
 const discordRPC = require('./discordRPC');
+const { downloadInstanceFiles, downloadFile } = require('./downloadFile');
 
 const gotTheLock = app.requestSingleInstanceLock();
 
@@ -901,6 +902,24 @@ ipcMain.handle('download-optedout-mods', async (e, { mods, instancePath }) => {
   }
 });
 
+ipcMain.handle(
+  'download-instance-files',
+  async (e, arr, updatePercentage, threads) => {
+    const back = downloadInstanceFiles(
+      mainWindow,
+      arr,
+      updatePercentage,
+      threads
+    );
+    log.log('Back:', back);
+    return back;
+  }
+);
+
+ipcMain.handle('download-file', async (e, fileName, url, onProgress) => {
+  return downloadFile(mainWindow, fileName, url, onProgress);
+});
+
 ipcMain.handle('start-listener', async (e, dirPath) => {
   try {
     log.log('Trying to start listener');

src/app/desktop/DesktopRoot.js

@@ -6,6 +6,8 @@ import { ipcRenderer } from 'electron';
 import { useSelector, useDispatch } from 'react-redux';
 import { push } from 'connected-react-router';
 import { message } from 'antd';
+import axios from 'axios';
+import adapter from 'axios/lib/adapters/http';
 import RouteWithSubRoutes from '../../common/components/RouteWithSubRoutes';
 import {
   loginWithAccessToken,
@@ -72,6 +74,11 @@ function DesktopRoot({ store }) {
   });
 
   const init = async () => {
+    console.log(axios.defaults.adapter);
+    axios.defaults.adapter = adapter;
+    console.log(axios.defaults.adapter);
+    console.log(adapter);
+
     dispatch(requesting(features.mcAuthentication));
     const userDataStatic = await ipcRenderer.invoke('getUserData');
     const userData = dispatch(updateUserData(userDataStatic));