@lazycatcloud/lzc-cli 1.1.0 → 1.1.3

package/lib/api.js

@@ -21,8 +21,7 @@ export default class API {
         body: fs.createReadStream(zipPath),
       }
     );
-    if (resp.status == 200) {
-    } else {
+    if (resp.status != 200) {
       throw chalk.red(await resp.text());
     }
     // update
@@ -71,10 +70,10 @@ export default class API {
         throw info?.msg;
       default:
         try {
-          await this.desireStatusTimer((result) => {
+          await desireStatusTimer((result) => {
             spinner.text = "部署进度 " + result.status;
             return result.status === "running";
-          });
+          }, this.status.bind(this));
         } catch (error) {
           throw error;
         } finally {
@@ -84,40 +83,39 @@ export default class API {
     }
     spinner.stop();
   }
+}
 
-  desireStatusTimer(desireCheckFn) {
-    let that = this;
-    const step = 2000;
-    return new Promise((resolve, reject) => {
-      function schedule(timeout) {
-        setTimeout(async () => {
-          try {
-            const answer = await that.status();
-            if (answer) {
-              if (answer.status == "error") {
-                timeout += step;
-                if (timeout > 1000 * 10) {
-                  reject(new Error(answer.error));
-                  return;
-                }
-                schedule(timeout);
-              } else if (desireCheckFn(answer)) {
-                resolve(answer);
-              } else {
-                schedule(1000);
+export function desireStatusTimer(desireCheckFn, getStatusFn) {
+  const step = 2000;
+  return new Promise((resolve, reject) => {
+    function schedule(timeout) {
+      setTimeout(async () => {
+        try {
+          const answer = await getStatusFn();
+          if (answer) {
+            if (answer.status == "error") {
+              timeout += step;
+              if (timeout > 1000 * 10) {
+                reject(new Error(answer.error));
+                return;
               }
+              schedule(timeout);
+            } else if (desireCheckFn(answer)) {
+              resolve(answer);
+            } else {
+              schedule(1000);
             }
-          } catch (e) {
-            timeout += step;
-            if (timeout > 1000 * 10) {
-              reject(e);
-              return;
-            }
-            schedule(timeout);
           }
-        }, timeout);
-      }
-      schedule(1000);
-    });
-  }
+        } catch (e) {
+          timeout += step;
+          if (timeout > 1000 * 10) {
+            reject(e);
+            return;
+          }
+          schedule(timeout);
+        }
+      }, timeout);
+    }
+    schedule(1000);
+  });
 }

package/lib/archiver.js

@@ -7,14 +7,10 @@ import {
   envsubstr,
 } from "./utils.js";
 
-import { execPreBuild } from "../lib/builder.js";
-
-import execa from "execa";
-
 import glob from "fast-glob";
 import path from "path";
 import fs from "fs";
-import Env from "./env.js";
+import env from "./env.js";
 import DockerCompose from "./docker-compose.js";
 
 class Archiver {
@@ -22,20 +18,25 @@ class Archiver {
     this.tmpDir = tmpDir;
   }
 
-  async load(baseDir) {
+  async load(baseDir, e) {
+    const allEnv = e ? e : env.all;
     // 1 拷贝 dotApp 路径至 temp
     this.dotAppDir = baseDir;
-    this.env = Env(baseDir);
     await copyDotAppDir(this.dotAppDir, this.tmpDir, {
-      env: this.env.all,
+      env: allEnv,
     });
   }
 
-  async add(cwd) {
-    const allEnv = {
-      ...this.env.all,
-      APP_IMAGE_NAME: this.env.get("APP_ID"),
-    };
+  // 用于替换一些docker-compose 内容
+  replace(dockerComposeContent) {
+    let base = new DockerCompose(path.join(this.tmpDir, "docker-compose.yml"));
+    base.merge({ content: dockerComposeContent });
+    base.save();
+  }
+
+  async add(cwd, e) {
+    const allEnv = e ? e : env.all;
+    Object.assign(allEnv, { APP_IMAGE_NAME: env.get("APP_ID") });
     const target = this.tmpDir;
     try {
       let base = new DockerCompose(path.join(target, "docker-compose.yml"));
@@ -49,22 +50,25 @@ class Archiver {
         let absFile = path.join(cwd, file);
         if (path.basename(file).startsWith("docker-compose")) {
           if (file.endsWith(".in")) {
-            const options = {
-              envs: toPair(allEnv),
-              syntax: "default",
-              protect: false,
-            };
-            const output = await envsubstr(fs.readFileSync(absFile, "utf8"), {
-              options,
-            });
-            base.merge({ content: output });
+            base.merge({ content: await this._doEnvSubStr(absFile, allEnv) });
           } else {
             base.merge({ path: absFile });
           }
         } else {
-          let targetAbsFile = path.join(target, file);
-          ensureDir(targetAbsFile);
-          fs.copyFileSync(absFile, targetAbsFile);
+          // 对其他模板做转换操作, 然后直接写入目标文件
+          let targetAbsFile;
+          if (file.endsWith(".in")) {
+            targetAbsFile = path.join(target, file.replace(/\.in$/, ""));
+            ensureDir(targetAbsFile);
+            fs.writeFileSync(
+              targetAbsFile,
+              await this._doEnvSubStr(absFile, allEnv)
+            );
+          } else {
+            targetAbsFile = path.join(target, file);
+            ensureDir(targetAbsFile);
+            fs.copyFileSync(absFile, targetAbsFile);
+          }
         }
       }
 
@@ -78,14 +82,29 @@ class Archiver {
     }
   }
 
-  async finalize() {
-    await this._changeContent();
-    return await archiveFolder(this.tmpDir);
+  async _doEnvSubStr(filepath, env = {}) {
+    const options = {
+      envs: toPair(env),
+      syntax: "default",
+      protect: false,
+    };
+    return await envsubstr(fs.readFileSync(filepath, "utf8"), {
+      options,
+    });
+  }
+
+  async finalize(zip = true) {
+    // await this._changeContent();
+    if (zip) {
+      return await archiveFolder(this.tmpDir);
+    } else {
+      return this.tmpDir;
+    }
   }
   //
   //     permissions:
   //     - lzcapis
-  //
+  // need REMOVE deprecated
   async _changeContent() {
     let base = new DockerCompose(path.join(this.tmpDir, "docker-compose.yml"));
     base
@@ -99,13 +118,13 @@ class Archiver {
           template[META_MARK]["ingress"].push({
             service: "lazycat-apis-sidecar",
             port: 8888,
-            subdomain: this.env.get("APP_ID"),
+            subdomain: env.get("APP_ID"),
             path: "/lzcapis/",
             auth: "oidc",
             authcallback: "/lzcapis/oidc-callback",
           });
           template["services"]["lazycat-apis-sidecar"] = {
-            image: "registry.linakesi.com/lazycat-apis-sidecar",
+            image: "registry.lazycat.cloud/lazycat-apis-sidecar",
             pull_policy: "always",
             // volumes_from: ["${APP_NAME}:rw"],
             volumes: ["lzcapis-lzcapp:/lzcapp"],

package/lib/box/hportal.js

@@ -0,0 +1,113 @@
+import fetch from "node-fetch";
+
+export class HportalManager {
+  constructor(apiHost) {
+    this.apiHost = apiHost;
+  }
+
+  async deleteBox(boxId) {
+    let url = `${this.apiHost}/admin/boxes/${boxId}`;
+    const resp = await fetch(url, { method: "DELETE" });
+    if (resp.status != 200) {
+      let text = await resp.text();
+      console.log("从 Hportal 删除盒子失败", text);
+    }
+  }
+
+  async addBox(boxName) {
+    let url = `${this.apiHost}/admin/boxes/${boxName}`;
+    const resp = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify({
+        box_name: boxName,
+      }),
+    });
+    if (resp.status != 200) {
+      let text = await resp.text();
+      console.log(`添加 ${boxName} 到 Hportal 失败`);
+      throw text;
+    }
+  }
+
+  async loginBox(boxId, user, password) {
+    let url = `${this.apiHost}/admin/loginBox`;
+    const resp = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify({
+        box_id: boxId,
+        password,
+        user,
+      }),
+    });
+    if (resp.status != 200) {
+      let text = await resp.text();
+      console.log(`登录失败`, text);
+      throw text;
+    }
+  }
+
+  async getBoxId(boxName) {
+    let boxs = await this.boxs(boxName);
+    if (boxs.length == 0) {
+      return "";
+    } else {
+      return boxs[0].boxId;
+    }
+  }
+
+  async boxs(boxName, defaultBoxName = "") {
+    let url = this.apiHost + "/admin/boxes";
+
+    let origin;
+    try {
+      const resp = await fetch(url);
+      if (resp.status == 200) {
+        origin = await resp.json();
+      }
+    } catch {
+      return [];
+    }
+
+    let all = origin.map((info) => {
+      let yesorno = info.box_name == defaultBoxName ? "yes" : "no";
+      let connect = info.status >= 200 ? "connect" : "disconnect";
+      return {
+        default: yesorno,
+        boxName: info.box_name,
+        boxId: info.box_id,
+        connect,
+      };
+    });
+
+    if (!boxName) {
+      return all;
+    }
+
+    let box = all.find((a) => a.boxName == boxName);
+    if (box) {
+      return [box];
+    } else {
+      return [];
+    }
+  }
+}
+
+// showBox 将 qemu 虚拟盒子 和 真实盒子 的信息合并起来展示
+export function showBoxInfo(vmInfos, rmInfos) {
+  let boxIds = vmInfos
+    .concat(rmInfos)
+    .map((info) => info.boxId)
+    .filter((value, index, self) => self.indexOf(value) == index);
+
+  if (boxIds.length == 0) {
+    console.log("没有找到任何盒子，创建一个吧!");
+  }
+
+  let result = [];
+  boxIds.forEach((boxId) => {
+    let vInfo = vmInfos.find((r) => r.boxId == boxId) || {};
+    let rInfo = rmInfos.find((r) => r.boxId == boxId) || {};
+    result.push(Object.assign({}, vInfo, rInfo));
+  });
+  console.table(result);
+}

package/lib/box/index.js

@@ -0,0 +1,135 @@
+#!/bin/node
+
+import fs from "node:fs";
+import path from "node:path";
+import { QemuVM, QemuResource } from "./qemu_vm_mgr.js";
+import { contextDirname } from "../utils.js";
+import env, { sdkEnv } from "../env.js";
+import { HportalManager, showBoxInfo } from "./hportal.js";
+
+async function initQemuVM() {
+  let defaultSchemeFile = path.join(
+    contextDirname(),
+    "box",
+    "schemes",
+    "vm_box_system_debian.json"
+  );
+  let scheme = JSON.parse(fs.readFileSync(defaultSchemeFile));
+  if (scheme.path.search(/\$HOME/) >= 0) {
+    let home = process.env["HOME"];
+    scheme.path = scheme.path.replace("$HOME", home);
+  }
+
+  if (scheme.path && !scheme.path.startsWith("/")) {
+    scheme.path = path.join(contextDirname(), "box-emulator", scheme.path);
+  }
+
+  // 使用本地网络 api 调试 new QemuResource(scheme.path, "http://127.0.0.1");
+  let resource = new QemuResource(scheme.path);
+  await resource.init();
+
+  let m = new QemuVM(scheme);
+  return m;
+}
+
+async function initHportal() {
+  let apiHost = "http://127.0.0.1:30553/api";
+  let m = new HportalManager(apiHost);
+  return m;
+}
+
+export function boxCommand(box) {
+  let subCommands = [
+    {
+      command: "create",
+      desc: "创建一个虚拟盒子，并注册运行",
+      handler: async () => {
+        let m = await initQemuVM();
+        let { boxName, boxId, user, password } = await m.createVM();
+        // 如果没有指定默认的盒子名称将会将第一个盒子作为默认的盒子
+        let defaultBoxName = env.get("DEFAULT_BOXNAME");
+        if (!defaultBoxName) {
+          // 新创建的盒子在初始化的时候，盒子里面需要安装hc的组件，需要一点时间，
+          // 所以这里并不对sdk url进行校验是否有效
+          await sdkEnv.setDefaultBoxName(boxName, false);
+        }
+
+        let h = await initHportal();
+        console.log("添加盒子到 Hportal ......");
+        await h.addBox(boxName);
+        console.log("正在使用管理员帐号密码登录中......");
+        await h.loginBox(boxId, user, password);
+        console.log("登录成功！");
+      },
+    },
+    {
+      command: "start <boxName>",
+      desc: "启动一个虚拟盒子",
+      handler: async ({ boxName }) => {
+        let m = await initQemuVM();
+        let boxid = await m.runVM(boxName);
+        if (boxid) {
+          console.log("盒子ID: ", boxid);
+        }
+      },
+    },
+    {
+      command: "stop <boxName>",
+      desc: "停止一个虚拟盒子",
+      handler: async ({ boxName }) => {
+        let m = await initQemuVM();
+        await m.stopVM(boxName);
+      },
+    },
+    {
+      command: "delete <boxName>",
+      desc: "删除一个盒子，并取消接管。如果盒子为虚拟盒子，将会删除其所具有的数据",
+      handler: async ({ boxName }) => {
+        let h = await initHportal();
+        let boxId = await h.getBoxId(boxName);
+        if (boxId) {
+          await h.deleteBox(boxId);
+        }
+        let m = await initQemuVM();
+        await m.deleteVM(boxName);
+      },
+    },
+    {
+      command: "info [boxName]",
+      desc: "获取一个虚拟盒子的信息",
+      handler: async ({ boxName }) => {
+        let m = await initQemuVM();
+        let defaultBoxName = env.get("DEFAULT_BOXNAME");
+
+        let rm = await initHportal();
+
+        let vmInfos = await m.infoVM(boxName, defaultBoxName);
+        let rmInfos = await rm.boxs(boxName, defaultBoxName);
+
+        // 过滤条件不满足
+        if (vmInfos.length == 0 && rmInfos == 0 && boxName != "") {
+          console.log(`${boxName} 盒子不存在`);
+          let allVmInfos = await m.infoVM("", defaultBoxName);
+          let allRmInfos = await rm.boxs("", defaultBoxName);
+          showBoxInfo(allVmInfos, allRmInfos);
+        } else {
+          showBoxInfo(vmInfos, rmInfos);
+        }
+      },
+    },
+    {
+      command: "switch <boxName>",
+      desc: "设置默认的盒子",
+      handler: async ({ boxName }) => {
+        await sdkEnv.setDefaultBoxName(boxName);
+      },
+    },
+  ];
+  box.command({
+    command: "box",
+    desc: "盒子管理",
+    builder: (args) => {
+      args.command(subCommands);
+    },
+  });
+}