@lazycatcloud/lzc-cli 1.1.0

package/lib/dev.js

@@ -0,0 +1,300 @@
+import execa from "execa";
+import { execSync } from "child_process";
+import fs from "fs";
+import {
+  GitIgnore,
+  isDirSync,
+  isFileExist,
+  urlHostname,
+  APP_SDK_HOSTNAME,
+} from "./utils.js";
+import path from "path";
+import os from "os";
+import Env from "./env.js";
+import _get from "lodash.get";
+import { execPreBuild } from "./builder.js";
+
+import Archiver from "../lib/archiver.js";
+
+async function sdkSSHAddr(env) {
+  let url = await env.get("SDK_URL");
+  return `${APP_SDK_HOSTNAME}@${urlHostname(url)}:2222`;
+}
+
+function ParseAppAddress(appId) {
+  return `${appId}.${appId}.lzcapp`;
+}
+
+class DevModule {
+  constructor(appId, cwd) {
+    this.appId = appId;
+    this.tempDir = path.join(cwd, "output/debug");
+    this.cwd = cwd;
+    this.env = Env(cwd);
+  }
+
+  reset() {
+    try {
+      fs.rmSync(this.tempDir, { recursive: true });
+    } catch (e) {}
+  }
+
+  // 生成一个包含ssh key的App
+  async fakeApp(command) {
+    const buildDir = path.join(this.cwd, `debug/${command}`);
+    try {
+      const allEnv = {
+        ...this.env.all,
+        APP_IMAGE_NAME: this.env.get("APP_ID"),
+      };
+      await execPreBuild(buildDir, allEnv);
+      let arch = new Archiver(this.tempDir);
+      await arch.load(this.cwd);
+      await arch.add(buildDir);
+      return await arch.finalize();
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  getAddress() {
+    return ParseAppAddress(this.appId);
+  }
+
+  // 使用tempDir中的private key进行连接
+  async portForward(localaddr) {
+    let localServer;
+
+    try {
+      if (!localaddr) {
+        let port = this.env.get("DEV_PORT");
+        localaddr = `0.0.0.0:${port}`;
+      }
+
+      localServer = execa.command(this.env.get("DEV_CMD"), {
+        stdio: "inherit",
+      });
+
+      const appAddr = this.getAddress();
+
+      let jump = await sdkSSHAddr(this.env);
+      const subproces = execa(
+        "ssh",
+        [
+          "-J",
+          jump,
+          "-o",
+          "StrictHostKeyChecking=no",
+          "-o",
+          "UserKnownHostsFile=/dev/null",
+          "-o",
+          "ConnectionAttempts=3",
+          "-o",
+          "ConnectTimeout=30",
+          "-o",
+          "LogLevel=ERROR",
+          "-R",
+          `/lazycat_cloud_debug.sock:${localaddr}`,
+          "root@" + appAddr,
+          "-i",
+          path.join(this.tempDir, "debug/ssh/id_ed25519"),
+          "-t",
+        ],
+        { stdio: ["pipe", "inherit", "inherit"] }
+      );
+
+      process.on("SIGINT", () => {
+        process.exit();
+      });
+
+      await subproces;
+    } catch (e) {
+      this.reset();
+      return Promise.reject(e);
+    } finally {
+      if (localServer) localServer.kill("SIGINT");
+    }
+  }
+
+  async syncProject(keyFile, appAddr) {
+    let jump = await sdkSSHAddr(this.env);
+    let rsh = [
+      "ssh",
+      "-J",
+      jump,
+      "-o",
+      `"StrictHostKeyChecking=no"`,
+      "-o",
+      `"UserKnownHostsFile=/dev/null"`,
+      "-o",
+      `"ConnectionAttempts=3"`,
+      "-o",
+      `"ConnectTimeout=30"`,
+      "-o",
+      `"LogLevel=ERROR"`,
+      "-i",
+      keyFile,
+    ].join(" ");
+    execSync(
+      `rsync --rsh='${rsh}' -czrPR . root@${appAddr}:/root/${this.appId} --filter=':- .gitignore' --exclude='node_modules' --exclude='.git' --delete`,
+      { stdio: ["ignore", "ignore", "inherit"] }
+    );
+  }
+
+  // fallback fs.watch on not darwin and windows platform
+  // FILEPATH directory or file path
+  // CALLBACK => function(eventType, filename)
+  //  fs.watch 虽然不支持递归，当可以直接监听整个文件夹的变动
+  async fallbackWatch(filepath, gitignore, callback) {
+    if (gitignore.contain(filepath)) {
+      return Promise.resolve();
+    }
+
+    fs.watch(filepath, callback);
+
+    // 如果为一个文件夹，则扫描当中是否含有子文件夹
+    if (isDirSync(filepath)) {
+      return gitignore.readdir(filepath, (err, files) => {
+        if (err) {
+          throw err;
+        }
+
+        if (files.length <= 0) {
+          return;
+        }
+
+        files.forEach((f) => {
+          if (f.isDirectory()) {
+            this.fallbackWatch(
+              path.join(filepath, f.name),
+              gitignore,
+              callback
+            );
+          }
+        });
+      });
+    }
+  }
+
+  // 监听非.gitignore文件
+  // TODO： 目前仅仅监听process.cwd()以下的文件
+  async watchFile(keyFile, appAddr) {
+    let callback = (eventType, filename) => {
+      this.syncProject(keyFile, appAddr);
+    };
+
+    try {
+      if (["darwin", "win32"].includes(os.platform())) {
+        // onle macos and window platform support recursive options
+        fs.watch(process.cwd(), { recursive: true }, callback);
+      } else {
+        // fallback to other platform
+        let gitignore = new GitIgnore();
+        this.fallbackWatch(process.cwd(), gitignore, callback);
+      }
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  // 保存一个dev shell状态的文件,如果重复执行dev shell
+  // 会先判断这个临时文件是否存在，如果不存在重新部署，更新流程
+  // 否则直接ssh连接
+  async storeShellStatus(keyFile, appAddr, isWatch) {
+    fs.writeFileSync(
+      path.join(this.tempDir, ".shellStatus"),
+      JSON.stringify({
+        keyFile,
+        appAddr,
+        isWatch,
+      })
+    );
+  }
+
+  hasShellStatus() {
+    return isFileExist(path.join(this.tempDir, ".shellStatus"));
+  }
+
+  async readShellStatus() {
+    return JSON.parse(
+      fs.readFileSync(path.join(this.tempDir, ".shellStatus"), "utf-8")
+    );
+  }
+
+  async directShell() {
+    let keyFile, appAddr, isWatch;
+    try {
+      ({ keyFile, appAddr, isWatch } = await this.readShellStatus());
+
+      if (!isWatch) {
+        await this.syncProject(keyFile, appAddr);
+        // 注册watch函数
+        await this.watchFile(keyFile, appAddr);
+
+        this.storeShellStatus(keyFile, appAddr, true);
+      }
+
+      await this.connectShell(keyFile, appAddr);
+    } catch (e) {
+      return Promise.reject(e);
+    } finally {
+      if (!isWatch) {
+        this.storeShellStatus(keyFile, appAddr, false);
+      }
+    }
+  }
+
+  async shell() {
+    let keyFile;
+    let appAddr;
+
+    try {
+      keyFile = path.join(this.tempDir, "debug/ssh/id_ed25519");
+      appAddr = this.getAddress();
+
+      // 当进入shell的时候，都同步一次
+      await this.syncProject(keyFile, appAddr);
+      // 注册watch函数
+      await this.watchFile(keyFile, appAddr);
+
+      this.storeShellStatus(keyFile, appAddr, true);
+
+      await this.connectShell(keyFile, appAddr);
+    } catch (e) {
+      console.log(e);
+      // this.reset();
+      return Promise.reject(e);
+    } finally {
+      // 当shell退出后，更新isWatch状态
+      this.storeShellStatus(keyFile, appAddr, false);
+    }
+  }
+
+  async connectShell(keyFile, appAddr) {
+    let jump = await sdkSSHAddr(this.env);
+    const subproces = execa(
+      "ssh",
+      [
+        "-J",
+        jump,
+        "-o",
+        "StrictHostKeyChecking=no",
+        "-o",
+        "UserKnownHostsFile=/dev/null",
+        "-o",
+        "ConnectionAttempts=3",
+        "-o",
+        "ConnectTimeout=30",
+        "-o",
+        "LogLevel=ERROR",
+        "root@" + appAddr,
+        "-i",
+        keyFile,
+      ],
+      { stdio: "inherit" }
+    );
+    await subproces;
+  }
+}
+
+export default DevModule;

package/lib/docker/promise.js

@@ -0,0 +1,91 @@
+import Docker from "dockerode";
+
+var wrappedProto = Docker.prototype;
+
+function denodeify(func) {
+  return function (...args) {
+    return new Promise((resolve, reject) => {
+      let input = [...args, (err, val) => (err ? reject(err) : resolve(val))];
+      func.apply(this, input);
+    });
+  };
+}
+
+function proxyPromise(method) {
+  var promisey = denodeify(method);
+  return function () {
+    return promisey.apply(this.$subject, arguments);
+  };
+}
+
+function promiseObj(target, input) {
+  for (var key in input) {
+    if (typeof input[key] !== "function") continue;
+    target[key] = proxyPromise(input[key]);
+  }
+  return target;
+}
+
+function PromiseProxy(subject) {
+  var result = Object.create(subject);
+  result.$subject = subject;
+  return promiseObj(result, subject);
+}
+
+function ContainerProxy(subject) {
+  var result = PromiseProxy(subject);
+  var exec = result.exec;
+  result.exec = function () {
+    return exec.apply(this, arguments).then(function (exec) {
+      return PromiseProxy(exec);
+    });
+  };
+  return result;
+}
+
+function DockerProxy(options) {
+  this.$subject = new Docker(options);
+}
+
+promiseObj(DockerProxy.prototype, wrappedProto);
+
+// sadly we need to wrap run directly as a promise to consolidate both
+// of the resulting arguments.
+DockerProxy.prototype.run = function (image, command, stream) {
+  var subject = this.$subject;
+  return new Promise(function (accept, reject) {
+    subject.run(image, command, stream, function (err, result, container) {
+      if (err) return reject(err);
+      accept({
+        result: result,
+        // re-wrap
+        container: ContainerProxy(container),
+      });
+    });
+  });
+};
+
+// We also have wrap createContainer manually as it returns
+DockerProxy.prototype.createContainer = function (opts) {
+  var subject = this.$subject;
+  return new Promise(function (accept, reject) {
+    subject.createContainer(opts, function (err, container) {
+      if (err) return reject(err);
+      accept(ContainerProxy(container));
+    });
+  });
+};
+
+DockerProxy.prototype.getImage = function (id) {
+  return PromiseProxy(this.$subject.getImage(id));
+};
+
+DockerProxy.prototype.getContainer = function (id) {
+  return ContainerProxy(this.$subject.getContainer(id));
+};
+
+DockerProxy.prototype.getVolume = function (name) {
+  return PromiseProxy(this.$subject.getVolume(name));
+};
+
+export default DockerProxy;

package/lib/docker-compose.js

@@ -0,0 +1,51 @@
+import yaml from "js-yaml";
+import fs from "fs";
+import mergeWith from "lodash.mergewith";
+import isArray from "lodash.isarray";
+
+export function load(filePath) {
+  return yaml.load(fs.readFileSync(filePath, "utf8"));
+}
+
+// 用于合并多个 DockerCompose 文件
+export default class DockerCompose {
+  constructor(basefile) {
+    this.basefile = basefile;
+    this.obj = load(basefile);
+  }
+  // 直接修改 yaml 内容
+  pipe(cb) {
+    cb.apply(this, [this.obj]);
+    return this;
+  }
+
+  // mergeFile({file: ""}) or merge({content: ""})
+  merge(context) {
+    let newObj;
+    if (context.file) {
+      newObj = load(context.file);
+    }
+    if (context.content) {
+      newObj = yaml.load(context.content);
+    }
+
+    this.obj = mergeWith(this.obj, newObj, (objValue, srcValue) => {
+      if (isArray(objValue)) {
+        return objValue.concat(srcValue);
+      }
+    });
+    return this;
+  }
+
+  // to: optional
+  save(to) {
+    fs.writeFileSync(
+      to || this.basefile,
+      yaml.dump(this.obj, {
+        styles: {
+          "!!null": "empty", // dump null as ""
+        },
+      })
+    );
+  }
+}

package/lib/env.js

@@ -0,0 +1,104 @@
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { ensureDir, APP_CONFIG_FILE } from "./utils.js";
+
+const GLOBAL_CONFIG_NAME = "box-config.json";
+
+const permitVars = [
+  "APP_ID",
+  "APP_NAME",
+  "APP_IMAGE_NAME",
+  "BUILD_CONTEXT",
+  "HTTP_SERVICE_PORT",
+  "DEV_PORT",
+  "DEV_CMD",
+  "SDK_URL",
+];
+
+const permitGlobalVars = ["SDK_URL"];
+
+class Env {
+  constructor(cwd) {
+    this.envPath = path.join(cwd, APP_CONFIG_FILE);
+    this.globalEnvPath = path.join(
+      os.homedir(),
+      ".config/lazycat",
+      GLOBAL_CONFIG_NAME
+    );
+    this.load();
+  }
+
+  load() {
+    this.allEnv = {};
+    this.env = {};
+    this.globalEnv = {};
+
+    if (fs.existsSync(this.envPath)) {
+      this.env = JSON.parse(fs.readFileSync(this.envPath));
+    }
+
+    if (fs.existsSync(this.globalEnvPath)) {
+      this.globalEnv = JSON.parse(fs.readFileSync(this.globalEnvPath));
+    }
+    this.updateAllEnv();
+  }
+
+  get isEnvExist() {
+    return fs.existsSync(this.envPath);
+  }
+
+  get all() {
+    return Object.keys(this.allEnv).reduce((p, c) => {
+      if (permitVars.includes(c)) p[c] = this.allEnv[c];
+      return p;
+    }, {});
+  }
+
+  hasKey(key) {
+    return Object.keys(this.allEnv).indexOf(key) > -1;
+  }
+
+  get(key) {
+    return this.allEnv[key];
+  }
+
+  updateAllEnv() {
+    this.allEnv = Object.assign({}, this.globalEnv, this.env);
+  }
+
+  setGlobal(pairs = {}) {
+    const configPath = this.globalEnvPath;
+    if (Object.keys(pairs).some((k) => permitGlobalVars.indexOf(k) < 0)) {
+      return;
+    }
+
+    ensureDir(configPath);
+    Object.assign(this.globalEnv, pairs);
+    fs.writeFileSync(configPath, JSON.stringify(this.globalEnv, null, "  "));
+    this.updateAllEnv();
+  }
+
+  set(pairs = {}) {
+    if (Object.keys(pairs).some((k) => permitVars.indexOf(k) < 0)) {
+      return;
+    }
+
+    ensureDir(this.envPath);
+    Object.assign(this.env, pairs);
+    fs.writeFileSync(this.envPath, JSON.stringify(this.env, null, "  "));
+    this.updateAllEnv();
+  }
+
+  stringify() {
+    let content = "";
+    Object.keys(this.all).forEach((key) => {
+      content += `${key}="${this.allEnv[key]}"\n`;
+    });
+    return content.trimEnd();
+  }
+}
+
+export default function (cwd) {
+  return new Env(cwd);
+}

package/lib/generator.js

@@ -0,0 +1,115 @@
+import glob from "fast-glob";
+import path from "path";
+import fs from "fs";
+import execa from "execa";
+import { isBinaryFileSync } from "isbinaryfile";
+import { contextDirname } from "./utils.js";
+import chalk from "chalk";
+
+const __dirname = contextDirname();
+
+export const TemplateConfig = {
+  vue: {
+    template: "vue",
+    defaultEnvs: {
+      HTTP_SERVICE_PORT: "8080",
+      BUILD_CONTEXT: ".lazycat/release",
+    },
+    after: async function (name) {
+      console.log(chalk.green("开始安装依赖"));
+
+      const subprocess = execa("npm", ["install"], {
+        cwd: path.join(process.cwd(), name),
+        stdio: "inherit",
+      });
+      await subprocess;
+      console.log(
+        chalk.green(
+          `
+✨ 懒猫云应用 ${name} 已创建:
+  ${chalk.yellow(`cd ${name}`)}
+  ${chalk.yellow(`npm run serve`)}
+将应用部署至设备中:
+  ${chalk.yellow(`lzc-cli deploy`)}
+          `.trim()
+        )
+      );
+    },
+  },
+  golang: {
+    template: "golang",
+    defaultEnvs: {
+      BUILD_CMD: "go build -o release .",
+      HTTP_SERVICE_PORT: "3000",
+    },
+    after: function (name) {
+      console.log(
+        chalk.green(
+          `
+✨ 懒猫云应用 ${name} 已创建:
+  ${chalk.yellow(`cd ${name}`)}
+  ${chalk.yellow(`go run .`)}
+将应用部署至设备中:
+  ${chalk.yellow(`lzc-cli deploy`)}
+`.trim()
+        )
+      );
+    },
+  },
+};
+
+class Generator {
+  constructor(context) {
+    this.context = context || {};
+    this.templateRoot = path.join(__dirname, "../template/");
+  }
+
+  async generate(from, to, opts = {}) {
+    const files = await this.loadFiles(from, opts.prefix);
+    this.writeFileTree(to, files);
+  }
+
+  async loadFiles(dirPath, prefix = "") {
+    const templateDir = path.join(this.templateRoot, dirPath);
+
+    const _files = await glob(["**/*"], { cwd: templateDir });
+    let content;
+    let files = {};
+    for (let p of _files) {
+      const sourcePath = path.join(templateDir, p);
+
+      const statInfo = fs.statSync(sourcePath);
+      const mode = statInfo.mode;
+      if (isBinaryFileSync(sourcePath)) {
+        content = fs.readFileSync(sourcePath);
+      } else {
+        content = fs.readFileSync(sourcePath, "utf8");
+      }
+      // change _ prefix file into dot file
+      if (p.startsWith("_")) {
+        p = p.replace("_", ".");
+      }
+
+      files[path.join(prefix, p)] = {
+        content,
+        mode,
+      };
+    }
+    return new Promise((resolve) => resolve(files));
+  }
+
+  writeFileTree(target, files) {
+    Object.keys(files).forEach((p) => {
+      const filePath = path.join(target, p);
+      if (!fs.existsSync(path.dirname(filePath))) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      }
+      console.log(`创建文件 ${filePath}`);
+      fs.writeFileSync(filePath, files[p].content, { mode: files[p].mode });
+    });
+  }
+}
+
+export default (context) => {
+  return new Generator(context);
+};