@lazycatcloud/lzc-cli 1.1.0

package/README.md

@@ -0,0 +1,21 @@
+## 开始使用
+
+### 命令行工具使用方法
+
+#### 创建项目
+
+```bash
+lzc-cli create a_project
+```
+
+#### 在本地打包镜像, 如果本地没有发布应用相关文件，会先执行 `init` 命令
+
+```bash
+lzc-cli build
+```
+
+#### 发布 app 至 app p 至 appdb
+
+```bash
+lzc-cli publish
+```

package/lib/api.js

@@ -0,0 +1,123 @@
+import fetch from "node-fetch";
+import ora from "ora";
+import chalk from "chalk";
+import fs from "fs";
+//
+// sdk 提供的API
+export default class API {
+  constructor(appId, host) {
+    this.appId = appId;
+    this.host = host;
+  }
+  // applyZip api 支持以下query
+  // build boolean 是否构建app容器
+  // pull boolean 是否从docker.io拉取image
+  async install(zipPath, params) {
+    let searchParams = new URLSearchParams(params);
+    const resp = await fetch(
+      `${this.host}/api/v1/app/applyZip?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: fs.createReadStream(zipPath),
+      }
+    );
+    if (resp.status == 200) {
+    } else {
+      throw chalk.red(await resp.text());
+    }
+    // update
+  }
+
+  async uninstall() {
+    return await fetch(`${this.host}/api/v1/app/uninstall?id=${this.appId}`, {
+      method: "DELETE",
+    });
+  }
+
+  async status() {
+    const resp = await fetch(`${this.host}/api/v1/app/status?id=${this.appId}`);
+    if (resp.status == 200) {
+      const status = await resp.json();
+      return status;
+    } else {
+      let text = await resp.text();
+      // console.error(chalk.red(`Status Code: ${resp.status} ${text}`));
+      throw text;
+    }
+  }
+
+  async postPublicKey(key) {
+    const resp = await fetch(`${this.host}/api/v1/register`, {
+      method: "POST",
+      body: key,
+    });
+    if (resp.status != 200) {
+      throw new Error(await resp.text());
+    }
+  }
+
+  async checkStatus() {
+    const spinner = ora().start();
+    let { status, info } = await this.status();
+    spinner.text = "部署进度 " + status;
+
+    switch (status) {
+      case "running":
+        console.log(chalk.yellow("应用正在运行中"));
+        break;
+      case "error":
+        spinner.stop();
+        console.log(status, info);
+        throw info?.msg;
+      default:
+        try {
+          await this.desireStatusTimer((result) => {
+            spinner.text = "部署进度 " + result.status;
+            return result.status === "running";
+          });
+        } catch (error) {
+          throw error;
+        } finally {
+          spinner.stop();
+        }
+        break;
+    }
+    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);
+              }
+            }
+          } catch (e) {
+            timeout += step;
+            if (timeout > 1000 * 10) {
+              reject(e);
+              return;
+            }
+            schedule(timeout);
+          }
+        }, timeout);
+      }
+      schedule(1000);
+    });
+  }
+}

package/lib/archiver.js

@@ -0,0 +1,128 @@
+import {
+  archiveFolder,
+  copyDotAppDir,
+  ensureDir,
+  toPair,
+  META_MARK,
+  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 DockerCompose from "./docker-compose.js";
+
+class Archiver {
+  constructor(tmpDir) {
+    this.tmpDir = tmpDir;
+  }
+
+  async load(baseDir) {
+    // 1 拷贝 dotApp 路径至 temp
+    this.dotAppDir = baseDir;
+    this.env = Env(baseDir);
+    await copyDotAppDir(this.dotAppDir, this.tmpDir, {
+      env: this.env.all,
+    });
+  }
+
+  async add(cwd) {
+    const allEnv = {
+      ...this.env.all,
+      APP_IMAGE_NAME: this.env.get("APP_ID"),
+    };
+    const target = this.tmpDir;
+    try {
+      let base = new DockerCompose(path.join(target, "docker-compose.yml"));
+      // 2 遍历当前路径, 拷贝至 temp, 同时对 docker-compose 做合并操作
+      const _files = await glob(["**"], {
+        cwd: cwd,
+        dot: true,
+      });
+
+      for (let file of _files) {
+        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 });
+          } else {
+            base.merge({ path: absFile });
+          }
+        } else {
+          let targetAbsFile = path.join(target, file);
+          ensureDir(targetAbsFile);
+          fs.copyFileSync(absFile, targetAbsFile);
+        }
+      }
+
+      base.save();
+
+      // if (opts.build || false) {
+      //   // new Builder()
+      // }
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  async finalize() {
+    await this._changeContent();
+    return await archiveFolder(this.tmpDir);
+  }
+  //
+  //     permissions:
+  //     - lzcapis
+  //
+  async _changeContent() {
+    let base = new DockerCompose(path.join(this.tmpDir, "docker-compose.yml"));
+    base
+      .pipe((template) => {
+        const meta = template[META_MARK];
+        if (
+          meta &&
+          Array.isArray(meta["permissions"]) &&
+          meta["permissions"].includes("lzcapis")
+        ) {
+          template[META_MARK]["ingress"].push({
+            service: "lazycat-apis-sidecar",
+            port: 8888,
+            subdomain: this.env.get("APP_ID"),
+            path: "/lzcapis/",
+            auth: "oidc",
+            authcallback: "/lzcapis/oidc-callback",
+          });
+          template["services"]["lazycat-apis-sidecar"] = {
+            image: "registry.linakesi.com/lazycat-apis-sidecar",
+            pull_policy: "always",
+            // volumes_from: ["${APP_NAME}:rw"],
+            volumes: ["lzcapis-lzcapp:/lzcapp"],
+            command: [
+              "--client-id=${LAZYCAT_AUTH_OIDC_CLIENT_ID}",
+              "--client-secret=${LAZYCAT_AUTH_OIDC_CLIENT_SECRET}",
+              "--client-url=https://${LAZYCAT_APP_ORIGIN}/lzcapis/",
+              "--issuer=${LAZYCAT_AUTH_OIDC_ISSUER_URL}",
+              "--prefix=lzcapis",
+              "--fs-root=/lzcapp/documents",
+            ],
+          };
+          template["volumes"]["lzcapis-lzcapp"] = null;
+        }
+      })
+      .save();
+  }
+}
+
+export default Archiver;

package/lib/builder.js

@@ -0,0 +1,183 @@
+// build strategies based on build.yml
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import execa from "execa";
+// import { archiveFolder } from "./utils.js";
+import { DockerClient } from "./sdk.js";
+import { DockerfileParser } from "dockerfile-ast";
+import glob from "fast-glob";
+import ignore from "@balena/dockerignore";
+import { createLogUpdate } from "log-update";
+
+export const PRE_BUILD_FILE = "build.sh";
+
+export async function execPreBuild(targetDir, env = {}) {
+  const buildFile = path.join(targetDir, PRE_BUILD_FILE);
+  if (!fs.existsSync(buildFile)) return;
+
+  const subproces = execa(buildFile, {
+    cwd: targetDir,
+    env: env,
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+  return await subproces;
+}
+
+// builder 需要在app 的场景下使用, 不过有两个路径要注意
+// 一个是 docker build 时的context. 这个一般是运行cli时候的路径
+// 一个是 .lazycat 的路径
+export default class Builder {
+  constructor(env) {
+    this.env = env;
+  }
+
+  async local() {}
+
+  async buildImage(contextDir, buildDir) {
+    try {
+      await this.dockerRemoteBuildV2(
+        contextDir,
+        path.join(buildDir, "Dockerfile")
+      );
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  // private functions
+
+  async collectContextFromDockerFile(contextDir, dockerfilePath) {
+    // const contextDir = path.join(process.cwd(), context);
+    // const dockerfilePath = path.join(process.cwd(), dockerfile);
+
+    if (!fs.existsSync(dockerfilePath)) {
+      throw "未发现 Dockerfile";
+    }
+
+    let src = [path.relative(contextDir, dockerfilePath)];
+
+    // 通过 COPY 和 ADD 获取所有context中的文件
+    // TODO 未处理 dockerignore 情况
+    const ast = DockerfileParser.parse(fs.readFileSync(dockerfilePath, "utf8"));
+    for (let a of ast.getInstructions()) {
+      if (["COPY", "ADD"].includes(a.getInstruction())) {
+        const from = a.getArguments()[0].getValue().replace(/^\//, "");
+
+        const fromFullPath = path.join(contextDir, from);
+
+        if (fs.existsSync(fromFullPath)) {
+          const stat = fs.statSync(path.join(contextDir, from));
+          if (stat.isDirectory()) {
+            let files = await glob(path.join(from, "**"), {
+              cwd: contextDir,
+            });
+            src = src.concat(files);
+          } else if (stat.isFile()) {
+            src.push(from);
+          }
+        } else {
+          // try use glob
+          let files = await glob(from, {
+            cwd: contextDir,
+          });
+          src = src.concat(files);
+        }
+      }
+    }
+    // filter by dockerignore
+    const dockerIgnoreFile = path.join(contextDir, ".dockerignore");
+    //
+    if (fs.existsSync(dockerIgnoreFile)) {
+      let ig = ignore();
+      let data = fs.readFileSync(dockerIgnoreFile, "utf8");
+      ig.add(data.split("\n"));
+      src = ig.filter(src);
+    }
+    return src;
+  }
+
+  // v2 版本会收集所有需要的context 文件,将其传入buildImage 方法中
+  async dockerRemoteBuildV2(contextDir, dockerfile) {
+    const env = this.env;
+    const src = await this.collectContextFromDockerFile(contextDir, dockerfile);
+    const host = new URL(env["SDK_URL"]).host;
+    const docker = await new DockerClient(host).init();
+    try {
+      console.log(chalk.green("开始在设备中构建镜像"));
+      let stream = await docker.buildImage(
+        {
+          context: contextDir,
+          src: src,
+        },
+        {
+          buildargs: env,
+          dockerfile: src[0],
+          t: env["APP_ID"],
+        }
+      );
+      await new Promise((resolve, reject) => {
+        let pulls = [];
+        let logUpdate;
+
+        function refresh() {
+          logUpdate(pulls.map((p) => `${p.id}: ${p.content}`).join("\n"));
+        }
+
+        function updatePull({ id, content }) {
+          let index = pulls.findIndex((p) => p.id == id);
+          if (index > -1) {
+            pulls[index] = {
+              id: id,
+              content: content,
+            };
+          } else {
+            pulls.push({
+              id: id,
+              content: content,
+            });
+          }
+        }
+
+        docker.modem.followProgress(
+          stream,
+          (err, res) => {
+            err ? reject(err) : resolve(res);
+          },
+          (res) => {
+            if (res.status) {
+              if (res.id) {
+                if (["Downloading", "Extracting"].includes(res.status)) {
+                  updatePull({
+                    id: res.id,
+                    content: `${res.status} ${res.progress}`,
+                  });
+                } else {
+                  updatePull({ id: res.id, content: res.status });
+                }
+
+                refresh();
+              } else {
+                process.stdout.write(res.status);
+                process.stdout.write("\n");
+              }
+            }
+
+            if (res.stream) {
+              if (res.stream.startsWith("Step")) {
+                pulls = [];
+                logUpdate = createLogUpdate(process.stdout);
+              }
+              process.stdout.write(res.stream);
+            }
+            if (res.error) {
+              reject(res.error);
+            }
+          }
+        );
+      });
+    } catch (err) {
+      throw err;
+    }
+  }
+}