[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,82 @@ ipcMainHandle("READ_FILE", async (_, { filePath }) => {
   }
 });
 
+ipcMainHandle(
+  "START_LIBRARY_DOWNLOAD_AND_INSTALL",
+  async (
+    _,
+    { engineId, libraryId, libraryName, libraryDownloadUrl, librarySize }
+  ) => {
+    return await libraryManager.startLibraryDownloadAndInstall(
+      engineId,
+      libraryId,
+      libraryName,
+      libraryDownloadUrl,
+      (status: LibraryInstallStatus) => {
+        if (status.status === "downloading") {
+          // contentLengthが0になる場合のための処理
+          if (status.contentLength === 0) {
+            win.setProgressBar(status.downloaded / librarySize);
+          } else {
+            win.setProgressBar(status.downloaded / status.contentLength);
+          }
+        } else if (
+          status.status === "pending" ||
+          status.status === "installing"
+        ) {
+          win.setProgressBar(2);
+        } else if (status.status === "error") {
+          win.setProgressBar(-1);
+          dialog.showErrorBox(
+            "ライブラリのインストールに失敗しました",
+            status.message
+          );
+        } else if (status.status === "done") {
+          win.setProgressBar(-1);
+        } else {
+          // status.status === "uninstalling"
+          throw Error(`Invalid status: ${status.status}`);
+        }
+        ipcMainSend(win, "UPDATE_LIBRARY_INSTALL_STATUS", {
+          libraryId,
+          status,
+        });
+      }
+    );
+  }
+);
+
+ipcMainHandle(
+  "UNINSTALL_LIBRARY",
+  async (_, { engineId, libraryId, libraryName }) => {
+    return await libraryManager.uninstallLibrary(
+      engineId,
+      libraryId,
+      libraryName,
+      (status: LibraryInstallStatus) => {
+        if (status.status === "pending" || status.status === "uninstalling") {
+          win.setProgressBar(2);
+        } else if (status.status === "error") {
+          win.setProgressBar(-1);
+          dialog.showErrorBox(
+            "ライブラリのインストールに失敗しました",
+            status.message
+          );
+        } else if (status.status === "done") {
+          win.setProgressBar(-1);
+        } else {
+          // status.status === "downloading" || status.status === "installing"
+          throw Error(`Invalid status: ${status.status}`);
+        }
+        ipcMainSend(win, "UPDATE_LIBRARY_INSTALL_STATUS", {
+          libraryId,
+          status,
+        });
+      }
+    );
+  }
+);
+
 // app callback
 app.on("web-contents-created", (e, contents) => {
   // リンククリック時はブラウザを開く

src/background/libraryManager.ts

@@ -0,0 +1,264 @@
+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";
+import { Result, failure, success } from "@/type/result";
+
+/**
+ * 音声ライブラリのダウンロードとインストール、アンインストールを行う
+ * インストール状況などの状態は持たない
+ */
+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;
+  }
+
+  private setEngineApi(engineId: EngineId, engineHost: string): void {
+    if (this.engineApis[engineId] === undefined) {
+      this.engineApis[engineId] = new DefaultApi(
+        new Configuration({ basePath: engineHost })
+      );
+    }
+  }
+
+  private async lockByEngineId(engineId: EngineId, fn: () => Promise<void>) {
+    await this.lock.acquire(`${engineId}`, fn);
+  }
+
+  /**
+   * 成功時・失敗時ともにステータス情報をonUpdateで通知して正常終了
+   */
+  async startLibraryDownloadAndInstall(
+    engineId: EngineId,
+    libraryId: LibraryId,
+    libraryName: string,
+    libraryDownloadUrl: string,
+    onUpdate: (status: LibraryInstallStatus) => void
+  ): Promise<Result<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}`
+      );
+      let reason: string;
+      if (downloadRes.status >= 400 && downloadRes.status < 500) {
+        switch (downloadRes.status) {
+          case 401:
+          case 403:
+            reason = "ダウンロードが拒否された";
+            break;
+          case 404:
+            reason = "ダウンロードするライブラリが見つからない";
+            break;
+          default:
+            reason = "アクセスに失敗した";
+            break;
+        }
+      } else if (downloadRes.status >= 500) {
+        switch (downloadRes.status) {
+          case 502:
+          case 503:
+            reason = "サーバーがダウンしている";
+            break;
+          case 504:
+            reason = "サーバーが時間内に応答しなかった";
+            break;
+          default:
+            reason = "サーバーでエラーが発生した";
+            break;
+        }
+      } else {
+        reason = "ダウンロード先のサーバーが不明なエラーを返した";
+      }
+      onUpdate({
+        status: "error",
+        message: `${reason}ため、現在このライブラリをダウンロードできません。（ステータスコード：${downloadRes.status}）`,
+      });
+      return failure(
+        "download",
+        new Error(`status code: ${downloadRes.status}`)
+      );
+    } else if (downloadRes.body === null) {
+      log.error(prefix + `Failed to download library: No body`);
+      onUpdate({
+        status: "error",
+        message: `ダウンロード先のサーバーがライブラリを返しませんでした`,
+      });
+      return failure("download", new Error("library not returned from server"));
+    }
+    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);
+    let tempFileClosed = false;
+
+    let result: Result<undefined>;
+    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();
+      tempFileClosed = true;
+      log.log(prefix + "Download complete");
+
+      this.setEngineApi(engineId, engine.host);
+      const libraryBuffer = await fs.promises.readFile(tempFilePath);
+
+      onUpdate({
+        status: "installing",
+      });
+      log.log(prefix + "Waiting for lock");
+
+      await this.lockByEngineId(engineId, async () => {
+        log.log(prefix + "Installing library");
+        await this.engineApis[
+          engineId
+        ].installLibraryInstallLibraryLibraryUuidPost(
+          {
+            libraryUuid: libraryId,
+          },
+          {
+            body: libraryBuffer,
+          }
+        );
+        log.log(prefix + "Library installed");
+      });
+      if (fs.existsSync(tempFilePath)) {
+        await fs.promises.rm(tempFilePath);
+      }
+      onUpdate({
+        status: "done",
+      });
+      result = success(undefined);
+    } catch (e) {
+      log.error(prefix + "Failed to install library");
+      log.error(e);
+      onUpdate({
+        status: "error",
+        message: `ライブラリのインストールに失敗しました。エラー内容：${e}`,
+      });
+      result = failure("install", new Error("failed to install library"));
+    } finally {
+      if (!tempFileClosed) {
+        tempFile.close();
+      }
+      if (fs.existsSync(tempFilePath)) {
+        log.log(prefix + "Removing temp file");
+        await fs.promises.rm(tempFilePath);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * 成功時・失敗時ともにステータス情報をonUpdateで通知して正常終了
+   */
+  async uninstallLibrary(
+    engineId: EngineId,
+    libraryId: LibraryId,
+    libraryName: string,
+    onUpdate: (status: LibraryInstallStatus) => void
+  ): Promise<Result<undefined>> {
+    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");
+
+    this.setEngineApi(engineId, engine.host);
+
+    try {
+      await this.lockByEngineId(engineId, async () => {
+        log.log(prefix + "Uninstalling library");
+        await this.engineApis[
+          engineId
+        ].uninstallLibraryUninstallLibraryLibraryUuidPost({
+          libraryUuid: libraryId,
+        });
+        log.log(prefix + "Library uninstalled");
+      });
+      onUpdate({
+        status: "done",
+      });
+      return success(undefined);
+    } catch (e) {
+      log.error(prefix + "Failed to uninstall library");
+      log.error(e);
+      onUpdate({
+        status: "error",
+        message: `ライブラリのアンインストールに失敗しました。エラー内容：${e}`,
+      });
+      return failure("uninstall", new Error("failed to uninstall library"));
+    }
+  }
+}
+
+export default LibraryManager;