[project-library-manage] ライブラリのインストール・アンインストール処理を実装

package.json

@@ -54,6 +54,7 @@
     "markdown-it": "12.0.4",
     "move-file": "3.0.0",
     "multistream": "4.1.0",
+    "node-fetch": "3.3.1",
     "quasar": "2.11.6",
     "semver": "7.3.5",
     "shlex": "2.1.2",
@@ -83,6 +84,7 @@
     "@types/markdown-it": "12.2.0",
     "@types/mousetrap": "1.6.8",
     "@types/multistream": "4.1.0",
+    "@types/node": "16.18.23",
     "@types/semver": "7.3.9",
     "@types/unzipper": "0.10.5",
     "@types/uuid": "8.3.4",

src/background.ts

@@ -30,6 +30,7 @@ import {
   defaultToolbarButtonSetting,
   engineSettingSchema,
   EngineId,
+  LibraryInstallStatus,
 } from "./type/preload";
 import {
   ContactTextFileName,
@@ -46,6 +47,7 @@ import EngineManager from "./background/engineManager";
 import VvppManager, { isVvppFile } from "./background/vvppManager";
 import configMigration014 from "./background/configMigration014";
 import { failure, success } from "./type/result";
+import LibraryManager from "./background/libraryManager";
 import { ipcMainHandle, ipcMainSend } from "@/electron/ipc";
 import { getStoreWithError } from "@/background/electronStore";
 
@@ -167,6 +169,10 @@ const engineManager = new EngineManager({
   onEngineProcessError,
 });
 const vvppManager = new VvppManager({ vvppEngineDir });
+const libraryManager = new LibraryManager({
+  engineManager,
+  tempDir: app.getPath("temp"),
+});
 
 // エンジンのフォルダを開く
 function openEngineDirectory(engineId: EngineId) {
@@ -942,6 +948,65 @@ ipcMainHandle("READ_FILE", async (_, { filePath }) => {
   }
 });
 
+ipcMainHandle(
+  "START_LIBRARY_DOWNLOAD_AND_INSTALL",
+  (_, { engineId, libraryId, libraryName, libraryDownloadUrl }) => {
+    libraryManager.startLibraryDownloadAndInstall(
+      engineId,
+      libraryId,
+      libraryName,
+      libraryDownloadUrl,
+      (status: LibraryInstallStatus) => {
+        if (status.status === "downloading" && status.contentLength) {
+          win.setProgressBar(status.downloaded / status.contentLength);
+        } else if (status.status === "installing") {
+          win.setProgressBar(2);
+        } else if (status.status === "error") {
+          win.setProgressBar(-1);
+          dialog.showErrorBox(
+            "ライブラリのインストールに失敗しました",
+            status.message
+          );
+        } else {
+          win.setProgressBar(-1);
+        }
+        ipcMainSend(win, "UPDATE_LIBRARY_INSTALL_STATUS", {
+          libraryId,
+          status,
+        });
+      }
+    );
+  }
+);
+
+ipcMainHandle(
+  "UNINSTALL_LIBRARY",
+  async (_, { engineId, libraryId, libraryName }) => {
+    await libraryManager.uninstallLibrary(
+      engineId,
+      libraryId,
+      libraryName,
+      (status: LibraryInstallStatus) => {
+        if (status.status === "uninstalling") {
+          win.setProgressBar(2);
+        } else if (status.status === "error") {
+          win.setProgressBar(-1);
+          dialog.showErrorBox(
+            "ライブラリのインストールに失敗しました",
+            status.message
+          );
+        } else {
+          win.setProgressBar(-1);
+        }
+        ipcMainSend(win, "UPDATE_LIBRARY_INSTALL_STATUS", {
+          libraryId,
+          status,
+        });
+      }
+    );
+  }
+);
+
 // app callback
 app.on("web-contents-created", (e, contents) => {
   // リンククリック時はブラウザを開く

src/background/libraryManager.ts

@@ -0,0 +1,195 @@
+import fs from "fs";
+import path from "path";
+import fetch from "node-fetch";
+import log from "electron-log";
+import AsyncLock from "async-lock";
+import EngineManager from "./engineManager";
+import { EngineId, LibraryId, LibraryInstallStatus } from "@/type/preload";
+import { Configuration, DefaultApi } from "@/openapi";
+
+export class LibraryManager {
+  engineManager: EngineManager;
+  tempDir: string;
+  lock: AsyncLock = new AsyncLock();
+  engineApis: Record<EngineId, DefaultApi> = {}; // ライブラリ管理のためだけに使う
+
+  constructor({
+    engineManager,
+    tempDir,
+  }: {
+    engineManager: EngineManager;
+    tempDir: string;
+  }) {
+    this.engineManager = engineManager;
+    this.tempDir = tempDir;
+  }
+
+  async startLibraryDownloadAndInstall(
+    engineId: EngineId,
+    libraryId: LibraryId,
+    libraryName: string,
+    libraryDownloadUrl: string,
+    onUpdate: (status: LibraryInstallStatus) => void
+  ): Promise<Buffer | undefined> {
+    const engine = this.engineManager.fetchEngineInfo(engineId);
+    const prefix = `LIBRARY INSTALL ${libraryName}: `;
+    log.log(
+      prefix +
+        `Started ${libraryName}, Engine: ${engine.name}, URL: ${libraryDownloadUrl}`
+    );
+    const downloadRes = await fetch(libraryDownloadUrl);
+    if (!downloadRes.ok) {
+      log.error(
+        prefix +
+          `Failed to download library: Server returned ${downloadRes.status}`
+      );
+      onUpdate({
+        status: "error",
+        message: `ダウンロード先のサーバーが${downloadRes.status}エラーを返しました`,
+      });
+      return;
+    } else if (downloadRes.body === null) {
+      log.error(prefix + `Failed to download library: No body`);
+      onUpdate({
+        status: "error",
+        message: `ダウンロード先のサーバーがライブラリを返しませんでした`,
+      });
+      return;
+    }
+    const tempFilePath = path.join(
+      this.tempDir,
+      `vv-temp-${engineId}-${libraryId}`
+    );
+    log.log(prefix + `Writing to ${tempFilePath}`);
+
+    const total = Number(downloadRes.headers.get("content-length"));
+    let downloaded = 0;
+    onUpdate({
+      status: "downloading",
+      contentLength: total,
+      downloaded,
+    });
+    const tempFile = fs.createWriteStream(tempFilePath);
+    try {
+      const progressInterval = 1024 * 1024;
+      let lastProgress = 0;
+      downloadRes.body.on("data", (chunk) => {
+        downloaded += chunk.length;
+        tempFile.write(chunk);
+        if (
+          Math.floor(downloaded) - Math.floor(lastProgress) >=
+          progressInterval
+        ) {
+          onUpdate({
+            status: "downloading",
+            contentLength: total,
+            downloaded,
+          });
+          if (total) {
+            log.log(
+              prefix +
+                `Downloaded ${downloaded}/${total} bytes (${(
+                  (downloaded / total) *
+                  100
+                ).toFixed(1)}%)`
+            );
+          } else {
+            log.log(
+              prefix +
+                `Downloaded ${downloaded} bytes (content-length header is not set)`
+            );
+          }
+          lastProgress = downloaded;
+        }
+      });
+      await new Promise((resolve) => {
+        if (!downloadRes.body) throw new Error("res.body is null");
+        downloadRes.body.on("end", resolve);
+      });
+      tempFile.close();
+      log.log(prefix + "Download complete");
+
+      if (this.engineApis[engineId] === undefined) {
+        this.engineApis[engineId] = new DefaultApi(
+          new Configuration({ basePath: engine.host })
+        );
+      }
+      const libraryBuffer = await fs.promises.readFile(tempFilePath);
+
+      onUpdate({
+        status: "installing",
+      });
+      log.log(prefix + "Waiting for lock");
+
+      await this.lock.acquire(`${engineId}`, async () => {
+        log.log(prefix + "Installing library");
+        await this.engineApis[
+          engineId
+        ].installLibraryInstallLibraryLibraryUuidPost(
+          {
+            libraryUuid: libraryId,
+          },
+          {
+            body: libraryBuffer,
+          }
+        );
+        log.log(prefix + "Library installed");
+      });
+      await fs.promises.rm(tempFilePath);
+      onUpdate({
+        status: "done",
+      });
+    } catch (e) {
+      log.error(prefix + "Failed to install library");
+      log.error(e);
+      onUpdate({
+        status: "error",
+        message: `ライブラリのインストールに失敗しました。エラー内容：${e}`,
+      });
+    } finally {
+      tempFile.close();
+      log.log(prefix + "Removing temp file");
+      await fs.promises.rm(tempFilePath);
+    }
+  }
+
+  async uninstallLibrary(
+    engineId: EngineId,
+    libraryId: LibraryId,
+    libraryName: string,
+    onUpdate: (status: LibraryInstallStatus) => void
+  ) {
+    const engine = this.engineManager.fetchEngineInfo(engineId);
+    const prefix = `LIBRARY UNINSTALL ${libraryName}: `;
+    log.log(prefix + `Started ${libraryName}, Engine: ${engine.name}`);
+
+    onUpdate({
+      status: "uninstalling",
+    });
+    log.log(prefix + "Waiting for lock");
+
+    try {
+      await this.lock.acquire(`${engineId}`, async () => {
+        log.log(prefix + "Uninstalling library");
+        await this.engineApis[
+          engineId
+        ].uninstallLibraryUninstallLibraryLibraryUuidPost({
+          libraryUuid: libraryId,
+        });
+        log.log(prefix + "Library uninstalled");
+      });
+      onUpdate({
+        status: "done",
+      });
+    } catch (e) {
+      log.error(prefix + "Failed to uninstall library");
+      log.error(e);
+      onUpdate({
+        status: "error",
+        message: `ライブラリのアンインストールに失敗しました。エラー内容：${e}`,
+      });
+    }
+  }
+}
+
+export default LibraryManager;

src/browser/sandbox.ts

@@ -313,4 +313,12 @@ export const api: Sandbox = {
   reloadApp(/* obj: { isMultiEngineOffMode: boolean } */) {
     throw new Error(`Not supported on Browser version: reloadApp`);
   },
+  startLibraryDownloadAndInstall(/* obj: { engineId: EngineId; library: DownloadableLibrary; } */) {
+    throw new Error(
+      `Not supported on Browser version: startLibraryDownloadAndInstall`
+    );
+  },
+  uninstallLibrary(/* pbj: { engineId: EngineId; libraryId: LibraryId; libraryName: string; } */) {
+    throw new Error(`Not supported on Browser version: uninstallLibrary`);
+  },
 };