@lazycatcloud/lzc-cli 1.1.7 → 1.1.9

package/lib/utils.js

@@ -1,136 +1,36 @@
 import path from "path";
 import fs from "fs";
-import { mkdtemp } from "fs/promises";
 import os from "os";
-import chalk from "chalk";
-import archiver from "archiver";
 import glob from "fast-glob";
 import yaml from "js-yaml";
 import mergeWith from "lodash.mergewith";
-import isArray from "lodash.isarray";
-import { request } from "./autologin.js";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
 import ignore from "ignore";
-import ora from "ora";
-import { desireStatusTimer } from "../lib/api.js";
-import { warn } from "console";
-import { createHash } from "node:crypto";
-
-const META_MARK = "x-lazycat-app";
-const APP_FOLDER = ".lazycat";
-const APP_CONFIG_FILE = "app-config";
-const APP_SDK_HOSTNAME = "box";
+import { createHash, randomBytes } from "node:crypto";
+import https from "node:https";
+import http from "node:http";
+import zlib from "node:zlib";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+import logger from "loglevel";
+
+export const APP_FOLDER = ".lazycat";
+export const APP_CONFIG_FILE = "app-config";
+export const APP_SDK_HOSTNAME = "box";
 export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), "/.config/lazycat");
 
 export const envsubstr = async (templateContents, args) => {
   const parse = await importDefault("envsub/js/envsub-parser.js");
   return parse(templateContents, args);
 };
-/**
- * 为盒子安装SDK应用
- * @param box_url 盒子入口地址
- **/
-async function InstallSDK(box_url) {
-  try {
-    let url = `${box_url}/api/app/apply?id=sdk`;
-    const resp = await request(url, { method: "post" });
-    if (resp.status != 200) {
-      throw new Error(
-        chalk.red(
-          `无法安装, 请确保 ${chalk.yellow(
-            new URL(url).origin
-          )} 可以访问或者在应用商店安装 sdk`
-        )
-      );
-    }
-  } catch (err) {
-    throw err;
-  }
-}
-/**
- * 检查SDK安装部署的状态
- * @param box_url 盒子入口地址
- **/
-async function checkSDKInstallStatus(box_url) {
-  const checkSDKstatus = async function (box_url) {
-    let url = `${box_url}/api/app/status?id=sdk`;
-    const resp = await request(url);
-    if (resp.status == 200) {
-      const status = await resp.json();
-      return status;
-    } else {
-      let text = await resp.text();
-      throw text;
-    }
-  };
-  const spinner = ora().start();
-  let { status, info } = await checkSDKstatus(box_url);
-  spinner.text = "部署进度";
-  switch (status) {
-    case "running":
-      console.log(chalk.yellow("应用正在运行中"));
-      break;
-    case "error":
-      spinner.stop();
-      console.log(status, info);
-      throw info.msg;
-    default:
-      try {
-        await desireStatusTimer(
-          (result) => {
-            spinner.text = "部署进度 " + result.status;
-            return result.status === "running";
-          },
-          () => {
-            return checkSDKstatus(box_url);
-          }
-        );
-      } catch (error) {
-        throw error;
-      } finally {
-        spinner.stop();
-      }
-      break;
-  }
-  spinner.stop();
-}
-
-/**
- * 获取所有已安装的app
- * @param box_url 盒子入口地址
- **/
-async function getInstalledApps(box_url) {
-  try {
-    let url = `${box_url}/api/app/dump`;
-    const resp = await request(url);
-    if (resp.status != 200) throw new Error(chalk.red("获取所有已安装App失败"));
-    return await resp.json();
-  } catch (e) {
-    console.log(e);
-  }
-}
-/**
- * 查找某个app是否已安装]
- * @param box_url 盒子入口地址
- * @param app_id app名
- * */
-async function findAppIsInstalled(box_url, app_id) {
-  const apps = await getInstalledApps(box_url);
-  for (let app in apps) {
-    if (app == app_id) {
-      return true;
-    }
-  }
-  return false;
-}
 
 /**
  * 确保文件夹存在
  * @param filePath {string} 如果为文件路径 确保其文件夹存在; 如果为文件夹, 则确保该文件夹存在
  *
  */
-function ensureDir(filePath) {
+export function ensureDir(filePath) {
   let dirPath;
   if (filePath.endsWith("/")) {
     dirPath = filePath;
@@ -142,11 +42,11 @@ function ensureDir(filePath) {
   }
 }
 
-function loadFromYaml(file) {
+export function loadFromYaml(file) {
   return yaml.load(fs.readFileSync(file, "utf8"));
 }
 
-function dumpToYaml(template, target) {
+export function dumpToYaml(template, target) {
   fs.writeFileSync(
     target,
     yaml.dump(template, {
@@ -157,42 +57,10 @@ function dumpToYaml(template, target) {
   );
 }
 
-function isValidApp(appDir) {
-  function doCheck(next = true) {
-    const files = ["docker-compose.yml", "docker-compose.yml.in"];
-    for (let f of files) {
-      const composeFile = path.join(appDir, f);
-      if (fs.existsSync(composeFile)) {
-        const doc = yaml.load(fs.readFileSync(composeFile, "utf8"));
-        if (doc[META_MARK]) {
-          return { appDir, isTemplate: f == "docker-compose.yml.in" };
-        }
-      }
-    }
-    if (next) {
-      appDir = path.join(appDir, APP_FOLDER);
-      return doCheck(false);
-    }
-    return { appDir: false, isTemplate: false };
-  }
-  return doCheck();
-}
-
-// find any valid app path till root folder
-function findAppRootPath(aPath) {
-  const sep = "/";
-  const folders = aPath.split(sep);
-  for (let i = folders.length; i >= 0; i--) {
-    if (folders[i] == APP_FOLDER) {
-      return folders.slice(0, i + 1).join(sep);
-    }
-  }
-  return false;
-}
-
-function toPair(object) {
+export function toPair(object) {
   return Object.keys(object).map((key) => {
     let value = object[key] ? object[key].toString() : "";
+    key = key.replaceAll("-", "_");
     return {
       name: key,
       value,
@@ -200,12 +68,7 @@ function toPair(object) {
   });
 }
 
-function getMetaInfo(composeFile) {
-  const doc = yaml.load(fs.readFileSync(composeFile, "utf8"));
-  return doc[META_MARK];
-}
-
-async function envTemplateFile(templateFile, env) {
+export async function envTemplateFile(templateFile, env) {
   const template = yaml.load(fs.readFileSync(templateFile, "utf8"));
   const options = {
     envs: toPair(env),
@@ -222,12 +85,12 @@ async function envTemplateFile(templateFile, env) {
   );
 }
 
-async function createTemplateFile(templateFile, outputFile, env) {
+export async function createTemplateFile(templateFile, outputFile, env) {
   let output = await envTemplateFile(templateFile, env);
   fs.writeFileSync(outputFile, output);
 }
 
-async function createTemplateFileCommon(templateFile, outputFile, env) {
+export async function createTemplateFileCommon(templateFile, outputFile, env) {
   const template = yaml.load(fs.readFileSync(templateFile, "utf8"));
   const options = {
     envs: toPair(env),
@@ -240,8 +103,17 @@ async function createTemplateFileCommon(templateFile, outputFile, env) {
   fs.writeFileSync(outputFile, output);
 }
 
+export async function envsubstrDefault(templateContents, env) {
+  const options = {
+    envs: toPair(env),
+    syntax: "default",
+    protect: false,
+  };
+  return envsubstr(templateContents, { options });
+}
+
 // this will copy current app to a tmp dir
-async function copyDotAppDir(from, to, opts = {}) {
+export async function copyDotAppDir(from, to, opts = {}) {
   const {
     include = [],
     ignore = ["app-config", "output", "box-config.json"],
@@ -278,7 +150,7 @@ async function copyDotAppDir(from, to, opts = {}) {
   }
 }
 
-function mergeYamlInMemory(args) {
+export function mergeYamlInMemory(args) {
   if (args.length == 0) {
     return {};
   } else if (args.length == 1) {
@@ -286,7 +158,7 @@ function mergeYamlInMemory(args) {
   }
   return args.reduce((prev, curr) => {
     let result = mergeWith(prev, curr, (objValue, srcValue) => {
-      if (isArray(objValue)) {
+      if (Array.isArray(objValue)) {
         return objValue.concat(srcValue);
       }
     });
@@ -295,14 +167,14 @@ function mergeYamlInMemory(args) {
 }
 
 // override yaml, notice this will change target file
-function mergeYaml(target, source) {
+export function mergeYaml(target, source) {
   const targetContent = yaml.load(fs.readFileSync(target, "utf8"));
   const sourceContent = yaml.load(fs.readFileSync(source, "utf8"));
   const merged = mergeWith(
     targetContent,
     sourceContent,
     (objValue, srcValue) => {
-      if (isArray(objValue)) {
+      if (Array.isArray(objValue)) {
         return objValue.concat(srcValue);
       }
     }
@@ -310,44 +182,16 @@ function mergeYaml(target, source) {
   dumpToYaml(merged, target);
 }
 
-function archiveFolder(appDir, format = "zip") {
-  return new Promise(async (resolve, reject) => {
-    if (!fs.existsSync(appDir)) {
-      reject(new Error("folder does not exist"));
-      return;
-    }
-
-    const tempDir = await mkdtemp(path.join(os.tmpdir(), "hc-"));
-    const out = path.join(tempDir, "app." + format);
-
-    // console.log(chalk.green("start archive app ..."));
-    const output = fs.createWriteStream(out);
-    const archive = archiver(format);
-
-    archive.on("error", (e) => {
-      reject(e);
-      // console.log(e);
-    });
-    archive.on("end", () => {
-      resolve(output);
-    });
-    archive.pipe(output);
-
-    archive.directory(appDir, false);
-    archive.finalize();
-  });
-}
-
-function contextDirname(url = import.meta.url) {
+export function contextDirname(url = import.meta.url) {
   return dirname(fileURLToPath(url));
 }
 
-async function importDefault(pkgPath) {
+export async function importDefault(pkgPath) {
   let mod = await import(pkgPath);
   return mod.default;
 }
 
-class GitIgnore {
+export class GitIgnore {
   constructor(root) {
     this.root = root;
     this.ignores = [];
@@ -385,12 +229,12 @@ class GitIgnore {
   }
 }
 
-function isDirSync(path) {
+export function isDirSync(path) {
   let stat = fs.statSync(path);
   return stat.isDirectory();
 }
 
-function isDirExist(path) {
+export function isDirExist(path) {
   try {
     return isDirSync(path);
   } catch {
@@ -398,7 +242,7 @@ function isDirExist(path) {
   }
 }
 
-function isFileExist(path) {
+export function isFileExist(path) {
   try {
     fs.accessSync(
       path,
@@ -410,60 +254,139 @@ function isFileExist(path) {
   }
 }
 
-function urlHostname(url) {
+export function urlHostname(url) {
   let u = new URL(url);
   return u.hostname;
 }
 
 // REVIEW: 用户输入的app-id 空格替换为减号并且转换为全小写。
 // 这会影响默认的app-name，因为app-name的默认值依赖app-id，但是如果特定输入了app-name则正常
-function parse2CorrectName(name) {
+export function parse2CorrectName(name) {
   return name.replaceAll(" ", "-").toLowerCase();
 }
 
-async function sleep(ms) {
+export async function sleep(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
 
-async function md5String(str) {
+export async function md5String(str) {
   const hash = createHash("md5");
   hash.update(str);
   return hash.digest("hex");
 }
 
-export {
-  ensureDir,
-  copyDotAppDir,
-  isValidApp,
-  getMetaInfo,
-  findAppRootPath,
-  archiveFolder,
-  mergeYaml,
-  mergeYamlInMemory,
-  loadFromYaml,
-  dumpToYaml,
-  importDefault,
-  APP_FOLDER,
-  APP_CONFIG_FILE,
-  APP_SDK_HOSTNAME,
-  META_MARK,
-  toPair,
-  contextDirname,
-  isDirSync,
-  isDirExist,
-  GitIgnore,
-  isFileExist,
-  urlHostname,
-  InstallSDK,
-  findAppIsInstalled,
-  getInstalledApps,
-  checkSDKInstallStatus,
-  envTemplateFile,
-  createTemplateFile,
-  parse2CorrectName,
-  sleep,
-  md5String,
-  createTemplateFileCommon
-};
+export async function md5File(filepath) {
+  const hash = createHash("md5");
+  const input = fs.createReadStream(filepath);
+  return new Promise((resolve) => {
+    input.on("readable", () => {
+      const data = input.read();
+      if (data) {
+        hash.update(data);
+      } else {
+        resolve(hash.digest("hex"));
+      }
+    });
+  });
+}
+
+export class Downloader {
+  constructor() {}
+
+  showDownloadingProgress(received, total) {
+    let percentage = ((received * 100) / total).toFixed(2);
+    process.stdout.write("\r");
+    process.stdout.write(
+      percentage +
+        "% | " +
+        received +
+        " bytes downloaded out of " +
+        total +
+        " bytes."
+    );
+  }
+
+  download(url, savePath, enableGzip = 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 (enableGzip) {
+          let decoder = zlib.createUnzip();
+          res.pipe(decoder).pipe(outputFile);
+        } else {
+          res.pipe(outputFile);
+        }
+
+        outputFile.on("error", reject);
+        outputFile.on("finish", () => {
+          fs.renameSync(tmpPath, savePath);
+          process.stdout.write("\n");
+          resolve();
+        });
+      });
+      req.on("error", reject);
+      req.end();
+    });
+  }
+}
+
+export function randomString(length = 4) {
+  return randomBytes(length).toString("hex");
+}
+
+export class FileLocker {
+  constructor(id) {
+    this.filename = undefined;
+    this.fd = undefined;
+    this.id = id;
+  }
+  lock() {
+    this.filename = path.resolve(os.tmpdir(), "lzc-cli-file-lock", this.id);
+    ensureDir(this.filename);
+
+    try {
+      this.fd = fs.openSync(this.filename, "wx+");
+    } catch (e) {
+      if (e.code == "EEXIST" && !this.withOpen(this.filename)) {
+        logger.debug("filelock exist open with w+");
+        this.fd = fs.openSync(this.filename, "w+");
+      } else {
+        throw e;
+      }
+    }
+  }
+  unlock() {
+    if (this.fd) {
+      fs.closeSync(this.fd);
+      fs.rmSync(this.filename);
+      this.fd = undefined;
+      this.filename = undefined;
+    }
+  }
+  withOpen(filename) {
+    const p = spawnSync("lsof", ["-w", "-t", filename]);
+    if (p.status === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@lazycatcloud/lzc-cli",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "lazycat cloud developer kit",
   "scripts": {
-    "test": "mocha",
-    "publish": "npm publish --access public"
+    "postinstall": "cp .githooks/* .git/hooks/",
+    "test": "tap",
+    "snap": "tap"
   },
-  "mocha": {
-    "recursive": true,
-    "reporter": "spec",
-    "timeout": 5000
+  "tap": {
+    "node-arg": [
+      "--loader=esmock",
+      "--experimental-vm-modules"
+    ]
   },
   "files": [
     "template",
@@ -28,7 +30,10 @@
   "license": "ISC",
   "dependencies": {
     "@balena/dockerignore": "^1.0.2",
+    "@improbable-eng/grpc-web": "^0.15.0",
+    "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
     "archiver": "^5.3.0",
+    "browser-headers": "^0.4.1",
     "chalk": "^4.1.2",
     "chokidar": "^3.5.3",
     "command-exists": "^1.2.9",
@@ -43,8 +48,8 @@
     "inquirer": "^8.2.0",
     "isbinaryfile": "^4.0.8",
     "js-yaml": "^4.1.0",
+    "lodash.debounce": "^4.0.8",
     "lodash.get": "^4.4.2",
-    "lodash.isarray": "^4.0.0",
     "lodash.merge": "^4.6.2",
     "lodash.mergewith": "^4.6.2",
     "log-update": "^5.0.0",
@@ -53,17 +58,20 @@
     "node-fetch": "^2.6.6",
     "node-stream-zip": "^1.15.0",
     "ora": "^6.0.1",
+    "protobufjs": "^7.1.1",
+    "rxjs": "^7.5.6",
     "semver": "^7.3.5",
     "ssh2": "^1.5.0",
     "ssh2-promise": "^1.0.2",
     "tar": "^6.1.11",
+    "urllib": "^3.1.0",
     "yargs": "^17.5.1"
   },
   "devDependencies": {
     "@types/command-exists": "^1.2.0",
-    "chai": "^4.3.6",
-    "mocha": "^9.2.2",
-    "prettier": "^2.5.0"
+    "esmock": "^2.0.0",
+    "prettier": "^2.5.0",
+    "tap": "^16.3.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",