feat: v0.2.1

Author: ZhiXiao-Lin

README.md

@@ -9,9 +9,6 @@ Node wrapper for nerdctl
 ```shell
 # Install Homebrew
 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-
-# Install Lima
-brew install lima
 ```
 
 ## Windows
@@ -73,15 +70,23 @@ yarn add nerdctl
 ```ts
 import { factory } from "nerdctl";
 
-const engine = factory();
+const callback: ProcessCallback = (data) => {
+  console.log(data);
+};
 
-await engine.initVM();
-await engine.startVM();
+const vm = factory();
+if (!(await vm.checkVM())) {
+  await vm.initVM(callback);
+}
+if (!(await vm.checkInstance())) {
+  await vm.initInstance(callback);
+}
 
 const IMAGE = "hello-world";
 
-await engine.pullImage(IMAGE);
-await engine.run(IMAGE);
+await vm.pullImage(IMAGE, callback);
+await vm.run(IMAGE, { rm: true }, callback);
+await vm.removeImage(IMAGE);
 ```
 
 ## License

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nerdctl",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "Node wrapper for nerdctl",

src/constants/app.ts

@@ -1,4 +1 @@
 export const APP_NAME = "node-nerdctl";
-export const IMAGE_VERSION = "0.2.9";
-export const ALPINE_EDITION = "rd";
-export const ALPINE_VERSION = "3.14.3";

src/index.ts

@@ -1,14 +1,13 @@
+import { isWindows, platform } from "./utils";
+
 import BaseBackend from "@/vms/base";
 import LimaBackend from "@/vms/lima";
 import WslBackend from "@/vms/wsl";
 import os from "os";
-import { platform } from "./utils";
 
-export function factory(
-  vm?: string,
-  instance: string = "default"
-): BaseBackend {
+export function factory(vm?: string, instance?: string): BaseBackend {
   const arch = os.arch() === "arm64" ? "aarch64" : "x86_64";
+  instance = instance ?? isWindows ? "Ubuntu-20.04" : "default";
   switch (platform) {
     case "linux":
       return new LimaBackend(arch, vm, instance);

src/tests/container.test.ts

@@ -1,10 +1,6 @@
-import { ChildProcess } from "child_process";
-import { ShellString } from "shelljs";
-
 export type Architecture = "x86_64" | "aarch64";
 
-export type ExecResult = ChildProcess | ShellString | null;
-
+export type ProcessCallback = (data: string) => void;
 export interface ChildResultType {
   stdout: string;
   stderr: string;

src/tests/images.test.ts

@@ -1,5 +1,5 @@
-import { Architecture, ExecResult } from "@/types";
-import { ExecOptions, ShellString, exec } from "shelljs";
+import { Architecture, ProcessCallback } from "@/types";
+import { ExecOptions, ShellString, exec, which } from "shelljs";
 import { ImageResult, RemoveImageCommandFlags } from "@/types/images";
 import {
   LogsCommandFlags,
@@ -39,10 +39,44 @@ export default abstract class BaseBackend {
     return `${this.vm} shell ${this.instance} ${this.runtime}`;
   }
 
+  //#region commons
+  protected async fork(
+    command: string,
+    callback?: ProcessCallback
+  ): Promise<boolean> {
+    const child = (await this.exec(command)) as ChildProcess;
+
+    return await new Promise((resolve) => {
+      child?.stdout?.on("data", (data) => {
+        callback && callback(data);
+      });
+      child?.stdout?.on("close", () => {
+        resolve(true);
+      });
+      child?.stderr?.on("data", (data) => {
+        callback && callback(data);
+      });
+      child?.stderr?.on("close", () => {
+        resolve(false);
+      });
+    });
+  }
+
+  protected async execSync(
+    command: string,
+    options?: Omit<ExecOptions, "async">
+  ): Promise<ShellString> {
+    return exec(command, {
+      silent: true,
+      async: false,
+      ...options,
+    }) as ShellString;
+  }
+
   protected async exec(
     command: string,
-    options?: ExecOptions
-  ): Promise<ExecResult> {
+    options?: Omit<ExecOptions, "async">
+  ): Promise<ChildProcess> {
     return exec(command, { silent: true, async: true, ...options });
   }
 
@@ -73,11 +107,22 @@ export default abstract class BaseBackend {
 
     return params;
   }
+  //#endregion
 
-  abstract initVM(): Promise<boolean>;
-  abstract startVM(): Promise<ChildProcess | null>;
-  abstract stopVM(): Promise<void>;
-  abstract deleteVM(): Promise<void>;
+  //#region VMs
+  async checkVM(): Promise<boolean> {
+    return !!which(this.vm);
+  }
+  async checkInstance(): Promise<boolean> {
+    return true;
+  }
+  async initVM(callback?: ProcessCallback): Promise<boolean> {
+    return true;
+  }
+  async initInstance(callback?: ProcessCallback): Promise<boolean> {
+    return true;
+  }
+  //#endregion
 
   //#region registry
   async login(
@@ -88,20 +133,25 @@ export default abstract class BaseBackend {
       flags
     )} ${server}`;
 
-    return (await this.exec(command, { async: false })) as ShellString;
+    return await this.execSync(command);
   }
 
   async logout(server?: string): Promise<ShellString> {
     const command = `${this.container} logout ${server}`;
 
-    return (await this.exec(command, { async: false })) as ShellString;
+    return await this.execSync(command);
   }
   //#endregion
 
   //#region containers
-  async run(image: string, flags?: RunCommandFlags): Promise<ChildProcess> {
+  async run(
+    image: string,
+    flags?: RunCommandFlags,
+    callback?: ProcessCallback
+  ): Promise<boolean> {
     const command = `${this.container} run ${this.mergeFlags(flags)} ${image}`;
-    return (await this.exec(command)) as ChildProcess;
+
+    return await this.fork(command, callback);
   }
 
   async stop(
@@ -111,10 +161,11 @@ export default abstract class BaseBackend {
     const containers = Array.isArray(container)
       ? container.join(" ")
       : container;
-    return (await this.exec(
-      `${this.container} stop ${this.mergeFlags(flags)} ${containers}`,
-      { async: false }
-    )) as ShellString;
+    const command = `${this.container} stop ${this.mergeFlags(
+      flags
+    )} ${containers}`;
+
+    return await this.execSync(command);
   }
 
   async remove(
@@ -124,25 +175,27 @@ export default abstract class BaseBackend {
     const containers = Array.isArray(container)
       ? container.join(" ")
       : container;
-    return (await this.exec(
-      `${this.container} rm ${this.mergeFlags(flags)} ${containers}`,
-      { async: false }
-    )) as ShellString;
+    const command = `${this.container} rm ${this.mergeFlags(
+      flags
+    )} ${containers}`;
+
+    return await this.execSync(command);
   }
 
-  async logs(
-    container: string,
-    flags?: LogsCommandFlags
-  ): Promise<ChildProcess> {
-    return (await this.exec(
-      `${this.container} logs ${this.mergeFlags(flags)} ${container}`
-    )) as ChildProcess;
+  async logs(container: string, flags?: LogsCommandFlags): Promise<boolean> {
+    const command = `${this.container} logs ${this.mergeFlags(
+      flags
+    )} ${container}`;
+
+    return await this.fork(command);
   }
   //#endregion
 
   //#region images
-  async pullImage(image: string): Promise<ChildProcess> {
-    return (await this.exec(`${this.container} pull ${image}`)) as ChildProcess;
+  async pullImage(image: string, callback?: ProcessCallback): Promise<boolean> {
+    const command = `${this.container} pull ${image}`;
+
+    return await this.fork(command, callback);
   }
 
   async getImages(): Promise<ImageResult[]> {
@@ -171,11 +224,9 @@ export default abstract class BaseBackend {
     flags?: RemoveImageCommandFlags
   ): Promise<ShellString> {
     const images = Array.isArray(image) ? image.join(" ") : image;
+    const command = `${this.container} rmi ${this.mergeFlags(flags)} ${images}`;
 
-    return (await this.exec(
-      `${this.container} rmi ${this.mergeFlags(flags)} ${images}`,
-      { async: false }
-    )) as ShellString;
+    return await this.execSync(command);
   }
   //#endregion
 }

src/types/index.ts

@@ -1,31 +1,11 @@
 import BaseBackend from "./base";
 import { ChildProcess } from "child_process";
 import { LimaListResult } from "@/types/lima";
+import { ProcessCallback } from "@/types";
 import { isM1 } from "@/utils";
-import { which } from "shelljs";
 
 export default class LimaBackend extends BaseBackend {
-  async initVM(): Promise<boolean> {
-    if (!which("brew")) return false;
-    if (!which(this.vm)) {
-      const command = `${isM1 ? `arch -arm64 ` : ""}brew install lima`;
-      const child = (await this.exec(command)) as ChildProcess;
-      await new Promise((resolve, reject) => {
-        child?.stdout?.on("data", (data) => {
-          console.log(data);
-        });
-        child?.stdout?.on("close", () => {
-          resolve(true);
-        });
-        child?.stderr?.on("data", (data) => {
-          console.log(data);
-        });
-        child?.stderr?.on("close", () => {
-          reject(false);
-        });
-      });
-    }
-
+  async checkInstance(): Promise<boolean> {
     const listChild = (await this.exec(
       `${this.vm} list --json`
     )) as ChildProcess;
@@ -53,17 +33,15 @@ export default class LimaBackend extends BaseBackend {
     return true;
   }
 
-  async startVM(): Promise<ChildProcess> {
-    return (await this.exec(
-      `${this.vm} start ${this.instance}`
-    )) as ChildProcess;
-  }
+  async initVM(callback?: ProcessCallback): Promise<boolean> {
+    const command = `${isM1 ? `arch -arm64 ` : ""}brew install lima`;
 
-  async stopVM(): Promise<void> {
-    await this.exec(`${this.vm} stop ${this.instance}`);
+    return await this.fork(command, callback);
   }
 
-  async deleteVM(): Promise<void> {
-    await this.exec(`${this.vm} delete ${this.instance}`);
+  async initInstance(callback?: ProcessCallback): Promise<boolean> {
+    const command = `${this.vm} start ${this.instance}`;
+
+    return await this.fork(command, callback);
   }
 }