@lazycatcloud/lzc-cli 1.1.0 → 1.1.3

package/lib/box/qemu_vm_mgr.js

@@ -0,0 +1,553 @@
+#!/bin/node
+import fs from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import path from "node:path";
+import inquirer from "inquirer";
+import https from "node:https";
+import http from "node:http";
+import lz4 from "lz4";
+import process from "node:process";
+import net from "node:net";
+
+async function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(() => {
+      let addr = server.address();
+      resolve(addr.port);
+      server.close();
+    });
+    server.on("error", reject);
+  });
+}
+
+function parseVmPID(vmDir) {
+  let p = spawnSync("pgrep", ["-f", path.join(vmDir, "disk-system.qcow2")]);
+  if (p.status == 0) {
+    return p.stdout.toString();
+  } else {
+    // 没有找到任何记录
+    return "";
+  }
+}
+
+export class QemuResource {
+  /**
+   * diskDir qemu 磁盘存储路径，默认 ~/.local/share/lazycat/box-emulator
+   * downloadUrl system-disk 下载路径
+   */
+  constructor(
+    diskDir = "~/.local/share/lazycat/box-emulator",
+    downloadUrl = "https://dl.lazycat.cloud/sdk/vm"
+  ) {
+    this.diskDir = diskDir;
+    this.downloadUrl = downloadUrl;
+  }
+
+  async init() {
+    fs.mkdirSync(this.diskDir, { recursive: true });
+    await this.ensureSystemDisk();
+  }
+
+  /**
+   * 确保 qemu 系统盘的镜像存在，如果不存在，将会从 downloadUrl 中下载
+   */
+  async ensureSystemDisk() {
+    let systemDiskFile = path.join(this.diskDir, "disk-system.qcow2");
+    try {
+      fs.accessSync(systemDiskFile);
+      return;
+    } catch {}
+
+    await this.downloadSystemDisk();
+    await this.downloadPrivateKey();
+  }
+
+  async downloadSystemDisk() {
+    let savePath = path.join(this.diskDir, "disk-system.qcow2");
+    let url = `${this.downloadUrl}/disk-system.qcow2.lz4`;
+    await this.download(url, savePath, true);
+  }
+
+  async downloadPrivateKey() {
+    let savePath = path.join(this.diskDir, "id_rsa");
+    let url = `${this.downloadUrl}/id_rsa`;
+    await this.download(url, savePath);
+    fs.chmodSync(savePath, 0o400);
+    return;
+  }
+
+  showDownloadingProgress(received, total) {
+    var percentage = ((received * 100) / total).toFixed(2);
+    process.stdout.write("\r");
+    process.stdout.write(
+      percentage +
+        "% | " +
+        received +
+        " bytes downloaded out of " +
+        total +
+        " bytes."
+    );
+  }
+
+  download(url, savePath, enableLz4 = false) {
+    let tmpPath = savePath + ".tmp";
+    const options = new URL(url);
+    let request = url.startsWith("https") ? https.request : http.request;
+
+    return new Promise((resolve, reject) => {
+      const req = request(options, (res) => {
+        if (res.statusCode != 200) {
+          reject(`下载 ${url} 失败`);
+          return;
+        }
+
+        let total = parseInt(res.headers["content-length"]);
+        let recive = 0;
+        res.on("data", (chunk) => {
+          recive += chunk.length;
+          this.showDownloadingProgress(recive, total);
+        });
+
+        let outputFile = fs.createWriteStream(tmpPath, { flags: "w+" });
+        if (enableLz4) {
+          let decoder = lz4.createDecoderStream();
+          res.pipe(decoder).pipe(outputFile);
+        } else {
+          res.pipe(outputFile);
+        }
+
+        outputFile.on("error", reject);
+        outputFile.on("finish", () => {
+          fs.renameSync(tmpPath, savePath);
+          resolve();
+        });
+      });
+      req.on("error", reject);
+      req.end();
+    });
+  }
+}
+
+export class QemuVM {
+  /**
+   * @param {Object} scheme - 各个操作系统的配置文件.
+   */
+  constructor(scheme) {
+    this.scheme = scheme;
+  }
+
+  /**
+   * 运行虚拟盒子，并等待 boxid 的出现，确保盒子启动正常
+   */
+  async startVM(name, vmDir) {
+    let args = await this.buildQemuArgs(name, vmDir);
+    let p = spawn("qemu-system-x86_64", args, {
+      detached: true,
+      stdio: ["ignore", "ignore", "inherit"],
+    });
+    console.log("启动中...");
+
+    // 需要等待 boxid 的出现
+    return new Promise((resolve, reject) => {
+      let count = 0;
+      let id = setInterval(() => {
+        if (count == 15) {
+          count = 0;
+        }
+        process.stdout.write("\r");
+        process.stdout.write("等待中" + ".".repeat(count));
+        count++;
+
+        if (p.exitCode) {
+          reject(`qemu 已经退出 Code: ${p.exitCode}`);
+          clearInterval(id);
+          return;
+        }
+
+        let boxid = this.readBoxid(name);
+        if (boxid) {
+          p.unref();
+          resolve(boxid);
+          clearInterval(id);
+          console.log("启动成功!");
+        }
+      }, 1000);
+    });
+  }
+
+  /**
+   * 运行一个指定的虚拟机，如果已经运行，将直接退出。如果盒子不存在，将报错退出
+   * @param {string} name - 盒子的名称
+   * @return {string} id - 盒子的id
+   **/
+  async runVM(name) {
+    let boxid = this.readBoxid(name);
+    if (!boxid) {
+      console.log(`${name} 盒子不存在，请通过 lzc-cli box create 创建`);
+      return;
+    }
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+    let pid = parseVmPID(vmDir);
+    if (pid) {
+      console.log(`${name} 盒子已经启动`);
+      return boxid;
+    }
+    await this.startVM(name, vmDir);
+    console.log(`${name} 盒子启动成功！`);
+  }
+
+  /**
+   * 创建一个指定的虚拟机，并启动等待注册成功。
+   **/
+  async createVM() {
+    let answer = await this.askBoxInfo();
+
+    let vmDir = this.ensureVmDir(answer.boxName);
+    this.ensureVolumeDir(vmDir);
+    await this.buildDisks(vmDir);
+    let boxId = await this.startVM(answer.boxName, vmDir);
+    console.log("盒子ID: ", boxId);
+
+    let boxName = await this.registerVM(boxId, answer);
+    return {
+      boxName,
+      boxId,
+      user: answer.adminName,
+      password: answer.adminPass,
+    };
+  }
+
+  /**
+   * 请求用户输入盒子的基本信息
+   **/
+  async askBoxInfo() {
+    const noEmpty = (value) => value != "";
+
+    return inquirer.prompt([
+      {
+        type: "input",
+        name: "boxName",
+        message: "请输入盒子名称：",
+        validate: noEmpty,
+      },
+      {
+        type: "input",
+        name: "adminName",
+        message: "请输入盒子管理员名称：",
+        default: "admin",
+      },
+      {
+        type: "password",
+        name: "adminPass",
+        message: "请输入盒子管理员密码：",
+        mask: "*",
+        validate: noEmpty,
+      },
+      {
+        type: "input",
+        name: "origin",
+        message: "注册服务器地址",
+        default: "origin.lazycat.cloud",
+      },
+    ]);
+  }
+
+  /**
+   * 调用 hportal client 进行注册
+   **/
+  async registerVM(boxid, { boxName, adminName, adminPass, origin }) {
+    // prettier-ignore
+    spawnSync("sudo",[
+      "-S",
+      "home-portal-client",
+      "-setup", "-boxid", boxid,
+      "-boxname", boxName,
+      "-user", adminName,
+      "-password", adminPass,
+      "-origin", origin,
+    ], {stdio: ["inherit", "inherit", "inherit"]})
+    return boxName;
+  }
+
+  /**
+   * 根据虚拟机名称确保缓存文件夹存在，返回对应的虚拟机缓存文件夹
+   */
+  ensureVmDir(name) {
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+    fs.mkdirSync(vmDir, { recursive: true });
+    return vmDir;
+  }
+
+  ensureVolumeDir(vmDir) {
+    for (let key in this.scheme.volume) {
+      let bindPath = `${vmDir}/volume-${key}`;
+      fs.mkdirSync(bindPath, { recursive: true });
+    }
+  }
+
+  /**
+   * 构建硬盘，从 scheme 中读取 disk 的配置信息，并构建。
+   */
+  async buildDisks(vmDir) {
+    for (const diskInfo of this.scheme.disks) {
+      let name = `disk-${diskInfo.id}.qcow2`;
+      let diskPath = path.join(vmDir, name);
+
+      try {
+        fs.accessSync(diskPath, fs.constants.F_OK);
+        continue;
+      } catch {}
+
+      if (diskInfo.system) {
+        await this.buildSystemDisk(name, diskPath, diskInfo);
+      } else {
+        await this.buildDataDisk(name, diskPath, diskInfo);
+      }
+    }
+  }
+
+  async buildSystemDisk(name, diskPath, diskInfo) {
+    console.log(`构建系统盘快照：${diskPath}`);
+    let baseImage = path.join(this.scheme.path, name);
+    return spawnSync(
+      "qemu-img",
+      ["create", "-f", "qcow2", "-b", baseImage, "-F", "qcow2", diskPath],
+      { stdio: "inherit" }
+    );
+  }
+
+  async buildDataDisk(name, diskPath, diskInfo) {
+    console.log(`构建数据盘：${diskPath}`);
+    return spawnSync(
+      "qemu-img",
+      ["create", "-f", "qcow2", diskPath, diskInfo.size],
+      { stdio: "inherit" }
+    );
+  }
+
+  /**
+   * 寻找默认可用的 bios 文件
+   */
+  findBIOS() {
+    let includes = ["/usr/share/ovmf/x64/OVMF.fd", "/usr/share/ovmf/OVMF.fd"];
+    for (let file of includes) {
+      try {
+        fs.accessSync(file, fs.constants.F_OK);
+        return file;
+      } catch {}
+    }
+
+    throw "找不到 ovmf 文件";
+  }
+
+  /**
+   * 构建 qemu 启动的参数
+   */
+  async buildQemuArgs(name, vmDir) {
+    let sshPort = await getFreePort();
+    let bios = this.findBIOS();
+    // prettier-ignore
+    let args = [
+      "-name", `${this.scheme.name}-${this.scheme.uuid}-vm-${name}`,
+      "-machine", "pc,accel=kvm",
+      "-m", `${this.scheme.memory}`,
+      "-smp", "4,sockets=4,cores=1,threads=1",
+      "-bios", bios,
+      "-device", "piix3-usb-uhci",
+      "-vnc", `unix:${vmDir}/.vnc`,
+      "-monitor", `unix:${vmDir}/.monitor,server,nowait`,
+      "-serial", `unix:${vmDir}/.serial,server,nowait`,
+      "-parallel", `unix:${vmDir}/.parallel,server,nowait`,
+      "-netdev", `user,hostfwd=tcp::${sshPort}-:22,id=eth`,
+      "-device", "virtio-net-pci,netdev=eth",
+      "-chardev", "stdio,id=s1,signal=off",
+      "-device", "isa-serial,chardev=s1",
+    ]
+
+    this.scheme.disks.forEach((diskInfo, index) => {
+      let file = `file=${vmDir}/disk-${diskInfo.id}.qcow2,format=qcow2,index=${index},media=disk,if=virtio`;
+      args.push("-drive", file);
+    });
+
+    Object.keys(this.scheme.volume).forEach((key) => {
+      let volumePath = this.scheme.volume[key];
+      let bindPath = `${vmDir}/volume-${key}`;
+      args.push(
+        "-virtfs",
+        `local,path=${bindPath},mount_tag=id_2245023265ae4cf87d02c8b6,security_model=mapped-xattr,id=id_2245023265ae4cf87d02c8b6`
+      );
+    });
+
+    return args;
+  }
+
+  /**
+   * 停止虚拟盒子
+   */
+  async stopVM(name) {
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+    let pid = parseVmPID(vmDir);
+    if (pid) {
+      process.kill(pid);
+    }
+    console.log(`${name} 盒子已停止`);
+  }
+
+  /**
+   * 删除虚拟盒子
+   */
+  async deleteVM(name) {
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+
+    try {
+      fs.accessSync(vmDir);
+    } catch {
+      console.log(`${name} 盒子不存在或者该盒子为一个真实盒子`);
+      return;
+    }
+
+    let pid = parseVmPID(vmDir);
+    if (pid) {
+      await inquirer
+        .prompt([
+          {
+            type: "confirm",
+            name: "yesorno",
+            message: `${name} 正在运行中，是否停止？`,
+            default: false,
+          },
+        ])
+        .then(async (answer) => {
+          if (!answer.yesorno) {
+            return;
+          }
+          process.kill(pid);
+          console.log(`${name} 盒子已停止`);
+        });
+    }
+
+    return inquirer
+      .prompt([
+        {
+          type: "confirm",
+          name: "yesorno",
+          message: `确定要删除 ${name} 盒子吗？`,
+          default: false,
+        },
+      ])
+      .then(async (answer) => {
+        if (!answer.yesorno) {
+          return;
+        }
+        fs.rmSync(vmDir, { recursive: true, force: true });
+      });
+  }
+
+  /**
+   * 从缓存路径中列出指定盒子信息
+   */
+  sigleVM(name, defaultBoxName = "") {
+    let volumeDir = path.join(this.scheme.path, `vm-${name}`, `volume-config`);
+
+    try {
+      fs.accessSync(volumeDir);
+    } catch {
+      return;
+    }
+
+    const read = (name) => {
+      try {
+        return fs.readFileSync(path.join(volumeDir, name), {
+          encoding: "utf-8",
+        });
+      } catch {
+        return "not found";
+      }
+    };
+
+    let boxName = read("box.name");
+
+    return {
+      default: boxName == defaultBoxName ? "yes" : "no",
+      boxName,
+      boxId: read("box.id"),
+    };
+  }
+
+  /**
+   * 从缓存路径中列出所有的盒子信息
+   */
+  infoAllVM(defaultBoxName = "") {
+    let entries = fs.readdirSync(this.scheme.path, { withFileTypes: true });
+    let result = [];
+
+    entries.forEach((entry) => {
+      if (!entry.isDirectory()) {
+        return;
+      }
+
+      if (!entry.name.startsWith("vm-")) {
+        return;
+      }
+
+      let name = entry.name.substr(3);
+      let info = this.sigleVM(name, defaultBoxName);
+      if (info) {
+        let pid = parseVmPID(path.join(this.scheme.path, entry.name));
+        info["vm status"] = pid ? "running" : "stop";
+        result.push(info);
+      }
+    });
+
+    return result;
+  }
+
+  /**
+   * 返回指定盒子信息
+   */
+  async infoSigleVM(name, defaultBoxName = "") {
+    let baseInfo = this.sigleVM(name, defaultBoxName);
+    if (!baseInfo) {
+      return [];
+    }
+
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+    baseInfo["vm status"] = parseVmPID(vmDir) ? "running" : "stop";
+    return [baseInfo];
+  }
+
+  /**
+   * 根据 scheme 中的 path 和 uuid 和 name 获取盒子的信息
+   */
+  async infoVM(name, defaultBoxName = "") {
+    let infos;
+    if (!name) {
+      infos = await this.infoAllVM(defaultBoxName);
+    } else {
+      infos = await this.infoSigleVM(name, defaultBoxName);
+    }
+    return infos;
+  }
+
+  /**
+   * 根据 scheme 中的 path 和 uuid 和 name 获取盒子的boxid
+   */
+  readBoxid(name) {
+    if (!this.scheme.volume["config"]) {
+      return "";
+    }
+
+    let vmDir = path.join(this.scheme.path, `vm-${name}`);
+    let volumeDir = path.join(vmDir, `volume-config`);
+
+    try {
+      let boxid = fs.readFileSync(path.join(volumeDir, "box.id"), {
+        encoding: "utf8",
+      });
+      return boxid;
+    } catch {
+      return "";
+    }
+  }
+}

package/lib/box/schemes/vm_box_system_debian.json

@@ -0,0 +1,47 @@
+{
+  "name": "home-cloud",
+  "uuid": "047dac31-b75b-46ed-aedb-a31fa46a6503",
+  "memory": 4096,
+  "kernel": "debian",
+  "uefi": true,
+  "path": "$HOME/.cache/box-emulator",
+  "volume": {
+    "config": "/etc/home-cloud"
+  },
+  "disks": [
+    {
+      "id": "system",
+      "size": "8G",
+      "system": true,
+      "partitions": [
+        {
+          "fs_type": "vfat",
+          "size": "100M",
+          "mount_point": "/boot/ESP"
+        },
+        {
+          "fs_type": "ext4",
+          "size": "4G",
+          "mount_point": "/"
+        },
+        {
+          "fs_type": "ext4",
+          "size": "full",
+          "mount_point": "/mnt"
+        }
+      ]
+    },
+    {
+      "id": "data1",
+      "size": "64G",
+      "system": false,
+      "partitions": []
+    },
+    {
+      "id": "data2",
+      "size": "64G",
+      "rebuild": false,
+      "partitions": []
+    }
+  ]
+}