@wocker/ws 1.0.1

package/lib/makes/Docker.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import Dockerode from "dockerode";
+type ContainerRunOptions = {
+    name: string;
+    image: string;
+    restart?: "always";
+    projectId?: string;
+    tty?: boolean;
+    links?: string[];
+    env?: {
+        [key: string]: string;
+    };
+    networkMode?: string;
+    extraHosts?: any;
+    volumes?: string[];
+    ports?: string[];
+    cmd?: string[];
+};
+type ImageBuildOptions = {
+    tag: string;
+    buildArgs?: {
+        [key: string]: string;
+    };
+    labels?: {
+        [key: string]: string;
+    };
+    context: string;
+    src: string;
+};
+declare class Docker {
+    static docker: Dockerode;
+    static exec(name: string, args: string[], tty?: boolean): Promise<import("stream").Duplex>;
+    static getImage(name: string): Promise<Dockerode.Image>;
+    static getContainer(name: any): Promise<Dockerode.Container>;
+    static removeContainer(name: string): Promise<void>;
+    static getContainerList(options?: {
+        name?: string;
+        projectId?: string;
+    }): Promise<Dockerode.ContainerInfo[]>;
+    static attach(name: string): Promise<void>;
+    static attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
+    static imageExists(tag: string): Promise<boolean>;
+    static imageLs(options?: {
+        tag?: string;
+        reference?: string;
+        labels?: {
+            [key: string]: string;
+        };
+    }): Promise<Dockerode.ImageInfo[]>;
+    static imageBuild(options: ImageBuildOptions): Promise<void>;
+    static imageBuild2(options: ImageBuildOptions): Promise<NodeJS.ReadableStream>;
+    static imageRm(name: string): Promise<void>;
+    static pullImage(tag: string): Promise<void>;
+    static createContainer(options: ContainerRunOptions): Promise<Dockerode.Container>;
+    static containerRun(options: ContainerRunOptions, attach?: boolean): Promise<Dockerode.Container>;
+}
+export { Docker };

package/lib/makes/Docker.js

@@ -0,0 +1,418 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Docker = void 0;
+var _dockerode = _interopRequireDefault(require("dockerode"));
+var _imageBuild = require("../utils/image-build");
+var _followProgress = require("../utils/followProgress");
+var _FS = require("./FS");
+var _Logger = require("./Logger");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const docker = new _dockerode.default({
+  socketPath: "/var/run/docker.sock"
+});
+class Docker {
+  static docker = docker;
+  static async exec(name, args, tty = true) {
+    const container = docker.getContainer(name);
+    const exec = await container.exec({
+      AttachStdin: true,
+      AttachStdout: true,
+      AttachStderr: tty,
+      Tty: tty,
+      Cmd: args
+    });
+    const stream = await exec.start({
+      hijack: true,
+      stdin: tty,
+      Tty: tty
+    });
+    if (tty) {
+      stream.setEncoding("utf-8");
+      process.stdin.resume();
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.setEncoding("utf-8");
+      process.stdin.pipe(stream);
+      stream.pipe(process.stdout);
+      stream.on("error", err => {
+        _Logger.Logger.error(err.message);
+      });
+      stream.on("end", async () => {
+        process.stdin.setRawMode(false);
+      });
+      stream.on("end", async () => {
+        process.exit();
+      });
+    }
+
+    // setTimeout(() => {
+    //     Logger.info("Exit");
+    //
+    //     process.exit();
+    // }, 4000);
+
+    return stream;
+  }
+  static async getImage(name) {
+    // let images = await exec(
+    //     "docker image ls" +
+    //     "   --filter=reference=\"" + name + "\""
+    // ).then((res:any) => {
+    //     let pos = {
+    //         0: "repository",
+    //         1: "tag",
+    //         2: "imageId",
+    //         3: "created",
+    //         4: "size"
+    //     };
+    //
+    //     res = res.stdout.split("\n").filter((line) => {
+    //         return line.split(new RegExp("\\s\\s+")).filter((item) => {
+    //             return item !== "";
+    //         }).length > 0;
+    //     }).map((line, index) => {
+    //         if(index === 0) {
+    //             return null;
+    //         }
+    //
+    //         let data = line.split(new RegExp("\\s\\s+"));
+    //
+    //         let row = {};
+    //
+    //         for(let i in data) {
+    //             let name = pos[i];
+    //
+    //             row[name] = data[i];
+    //         }
+    //
+    //         return row;
+    //     }).filter((line) => {
+    //         if(!line) {
+    //             return false;
+    //         }
+    //
+    //         return true;
+    //     });
+    //
+    //     return res;
+    // }).catch((err:any) => {
+    //     console.error(err);
+    //
+    //     return [];
+    // });
+    //
+    // return lodash.get(images, "[0]", null);
+
+    return docker.getImage(name);
+  }
+  static async getContainer(name) {
+    const containers = await docker.listContainers({
+      all: true,
+      filters: {
+        name: [name]
+      }
+    });
+    const container = containers.find(container => {
+      return container.Names.indexOf("/" + name) >= 0;
+    });
+    if (container) {
+      return docker.getContainer(container.Id);
+    }
+    return null;
+    // let res = await utils.exec(
+    //     "docker container ls" +
+    //     "   --filter=name=\"" + name + "\""
+    // );
+
+    // let containers = utils.parseTable(res.stdout, {
+    //     0: "containerId",
+    //     1: "image",
+    //     2: "command",
+    //     3: "created",
+    //     4: "status",
+    //     5: "ports",
+    //     6: "names"
+    // });
+
+    // await new Promise((resolve) => {
+    //     docker.listContainers({
+    //         "all": true
+    //     }, (err, containers) => {
+    //         console.log(containers);
+    //
+    //         resolve();
+    //     });
+    // });
+  }
+
+  static async removeContainer(name) {
+    const container = await Docker.getContainer(name);
+    if (!container) {
+      return;
+    }
+    const {
+      State: {
+        Status
+      }
+    } = await container.inspect();
+    if (Status === "running") {
+      try {
+        await container.stop();
+      } catch (err) {
+        _Logger.Logger.error("Docker.removeContainer: ", err.message);
+      }
+    }
+    try {
+      await container.remove();
+    } catch (err) {
+      _Logger.Logger.error("Docker.removeContainer: ", err.message);
+    }
+  }
+  static async getContainerList(options) {
+    const {
+      name,
+      projectId
+    } = options || {};
+    const filters = {};
+    if (name) {
+      filters.name = [`/${name}`];
+    }
+    if (projectId) {
+      if (!filters.label) {
+        filters.label = [];
+      }
+      filters.label.push(`projectId=${projectId}`);
+    }
+    return docker.listContainers({
+      all: true,
+      filters: JSON.stringify(filters)
+    });
+  }
+  static async attach(name) {
+    const container = await Docker.getContainer(name);
+    const stream = await container.attach({
+      logs: true,
+      stream: true,
+      hijack: true,
+      stdin: true,
+      stdout: true,
+      stderr: true
+    });
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.setRawMode(true);
+    process.stdin.pipe(stream);
+    process.stdin.on("data", data => {
+      if (data.toString() === "\u0003") {
+        process.stdin.setRawMode(false);
+      }
+    });
+    stream.setEncoding("utf8");
+    stream.pipe(process.stdout);
+    const [width, height] = process.stdout.getWindowSize();
+    await container.resize({
+      w: width,
+      h: height
+    });
+    stream.on("end", async () => {
+      process.exit();
+    });
+    process.stdout.on("resize", () => {
+      const [width, height] = process.stdout.getWindowSize();
+      container.resize({
+        w: width,
+        h: height
+      });
+    });
+  }
+  static async attachStream(stream) {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.pipe(stream);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    stream.setEncoding("utf8");
+    stream.pipe(process.stdout);
+    const end = () => {
+      process.stdin.pause();
+      process.stdin.unpipe(stream);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      stream.unpipe(process.stdout);
+    };
+    await new Promise((resolve, reject) => {
+      stream.on("end", end);
+      stream.on("error", end);
+      stream.on("end", resolve);
+      stream.on("error", reject);
+    });
+  }
+  static async imageExists(tag) {
+    const image = docker.getImage(tag);
+    try {
+      await image.inspect();
+      return true;
+    } catch (ignore) {
+      return false;
+    }
+  }
+  static async imageLs(options) {
+    const {
+      tag,
+      reference,
+      labels
+    } = options || {};
+    const filters = {};
+    if (reference) {
+      filters.reference = [...(filters.reference || []), reference];
+    }
+    if (tag) {
+      filters.reference = [...(filters.reference || []), tag];
+    }
+    if (labels) {
+      filters.label = [];
+      for (const i in labels) {
+        filters.label.push(`${i}=${labels[i]}`);
+      }
+    }
+    return docker.listImages({
+      filters: JSON.stringify(filters)
+    });
+  }
+  static async imageBuild(options) {
+    // await docker.buildImage({
+    //     context:
+    // });
+
+    await (0, _imageBuild.imageBuild)(options);
+  }
+  static async imageBuild2(options) {
+    const {
+      tag,
+      labels = {},
+      buildArgs = {},
+      context,
+      src
+    } = options;
+    const files = await _FS.FS.readdirFiles(context, {
+      recursive: true
+    });
+    const stream = await docker.buildImage({
+      context,
+      src: files
+    }, {
+      t: tag,
+      labels,
+      dockerfile: src,
+      buildargs: buildArgs
+    });
+    return stream;
+  }
+  static async imageRm(name) {
+    const image = await docker.getImage(name);
+    if (!image) {
+      return;
+    }
+    await image.remove();
+  }
+  static async pullImage(tag) {
+    const isExists = await this.imageExists(tag);
+    if (isExists) {
+      return;
+    }
+    const stream = await docker.pull(tag, {});
+    await (0, _followProgress.followProgress)(stream);
+  }
+  static async createContainer(options) {
+    const {
+      name,
+      tty,
+      image,
+      projectId,
+      restart,
+      extraHosts,
+      networkMode,
+      links = [],
+      env = {},
+      volumes = [],
+      ports = [],
+      cmd = []
+    } = options;
+    return await docker.createContainer({
+      name,
+      Image: image,
+      Hostname: name,
+      Labels: {
+        ...(projectId ? {
+          projectId
+        } : {})
+      },
+      AttachStdin: true,
+      AttachStdout: true,
+      AttachStderr: true,
+      OpenStdin: true,
+      StdinOnce: false,
+      Tty: tty,
+      Cmd: cmd,
+      Env: Object.keys(env).map(key => {
+        const value = env[key];
+        return `${key}=${value}`;
+      }),
+      ExposedPorts: ports.reduce((res, value) => {
+        const [,, containerPort] = /(\d+):(\d+)/.exec(value) || [];
+        if (containerPort) {
+          res[`${containerPort}/tcp`] = {};
+        }
+        return res;
+      }, {}),
+      HostConfig: {
+        NetworkMode: networkMode,
+        ExtraHosts: extraHosts,
+        ...(restart ? {
+          RestartPolicy: {
+            Name: restart
+          }
+        } : {}),
+        Binds: volumes,
+        PortBindings: ports.reduce((res, value) => {
+          const [, hostPort, containerPort] = /(\d+):(\d+)/.exec(value) || [];
+          if (hostPort && containerPort) {
+            res[`${containerPort}/tcp`] = [{
+              HostPort: hostPort
+            }];
+          }
+          return res;
+        }, {})
+      },
+      NetworkingConfig: {
+        EndpointsConfig: networkMode === "host" ? {} : {
+          workspace: {
+            Links: links
+          }
+        }
+      }
+    });
+  }
+  static async containerRun(options, attach = false) {
+    const container = await Docker.createContainer(options);
+    if (attach) {
+      const stdout = await container.attach({
+        // logs: true,
+        stream: true,
+        stdin: true,
+        stdout: true,
+        stderr: true
+      });
+      stdout.pipe(process.stdout);
+    }
+    await container.start();
+    return container;
+  }
+}
+exports.Docker = Docker;

package/lib/makes/FS.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as fs from "fs";
+import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions, RmOptions } from "fs";
+import { PassThrough } from "readable-stream";
+type ReaddirFilesOptions = {
+    recursive?: boolean;
+};
+declare class FS {
+    static access(path: PathLike): Promise<any>;
+    static exists(path: PathLike): Promise<boolean>;
+    static existsSync(path: PathLike): boolean;
+    static mkdir(dirPath: string, options?: MakeDirectoryOptions): Promise<void>;
+    static mkdirSync(path: any, options?: MakeDirectoryOptions): string;
+    static readdir(path: PathLike): Promise<string[]>;
+    static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
+    static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
+    static appendFileSync(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): void;
+    static read(): void;
+    static readBytes(filePath: PathLike, position?: number | bigint, size?: number | bigint): Promise<Buffer>;
+    static readFile(filePath: PathLike | number): Promise<Buffer>;
+    static readFileSync(filePath: PathLike): Buffer;
+    static writeFile(filePath: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
+    static writeFileSync(path: PathLike, data: any, options?: WriteFileOptions): void;
+    static createWriteStream(path: PathLike): fs.WriteStream;
+    static readJSON(filePath: PathLike | number): Promise<any>;
+    static writeJSON(filePath: PathLike | number, data: any): Promise<void>;
+    static unlink(filePath: PathLike): Promise<void>;
+    static watch(filename: PathLike, options?: any): fs.FSWatcher;
+    static stat(filename: PathLike, options?: Parameters<typeof fs.stat>[1]): Promise<Stats | BigIntStats>;
+    static createReadStream(path: PathLike, options?: Parameters<typeof fs.createReadStream>[1]): fs.ReadStream;
+    static createReadLinesStream(path: PathLike, count?: number): PassThrough;
+    static copyFile(src: PathLike, dest: PathLike): Promise<void>;
+    static rm(path: PathLike, options?: RmOptions): Promise<unknown>;
+}
+export { FS };