@wocker/ws 1.0.1 → 1.0.3

package/lib/makes/Docker.js

@@ -1,418 +1,320 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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"
+const dockerode_1 = __importDefault(require("dockerode"));
+const image_build_1 = require("../utils/image-build");
+const followProgress_1 = require("../utils/followProgress");
+const FS_1 = require("./FS");
+const Logger_1 = require("./Logger");
+const docker = new dockerode_1.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);
+    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_1.Logger.error(err.message);
+            });
+            stream.on("end", async () => {
+                process.stdin.setRawMode(false);
+            });
+            stream.on("end", async () => {
+                process.exit();
+            });
+        }
+        return stream;
     }
-    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;
+    static async getImage(name) {
+        return docker.getImage(name);
     }
-    const {
-      State: {
-        Status
-      }
-    } = await container.inspect();
-    if (Status === "running") {
-      try {
-        await container.stop();
-      } catch (err) {
-        _Logger.Logger.error("Docker.removeContainer: ", err.message);
-      }
+    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;
     }
-    try {
-      await container.remove();
-    } catch (err) {
-      _Logger.Logger.error("Docker.removeContainer: ", err.message);
+    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_1.Logger.error("Docker.removeContainer: ", err.message);
+            }
+        }
+        try {
+            await container.remove();
+        }
+        catch (err) {
+            Logger_1.Logger.error("Docker.removeContainer: ", err.message);
+        }
     }
-  }
-  static async getContainerList(options) {
-    const {
-      name,
-      projectId
-    } = options || {};
-    const filters = {};
-    if (name) {
-      filters.name = [`/${name}`];
+    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)
+        });
     }
-    if (projectId) {
-      if (!filters.label) {
-        filters.label = [];
-      }
-      filters.label.push(`projectId=${projectId}`);
+    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
+            });
+        });
     }
-    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);
+    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);
+        });
     }
-    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 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];
+    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)
+        });
     }
-    if (tag) {
-      filters.reference = [...(filters.reference || []), tag];
+    static async imageBuild(options) {
+        await (0, image_build_1.imageBuild)(options);
     }
-    if (labels) {
-      filters.label = [];
-      for (const i in labels) {
-        filters.label.push(`${i}=${labels[i]}`);
-      }
+    static async imageBuild2(options) {
+        const { tag, labels = {}, buildArgs = {}, context, src } = options;
+        const files = await FS_1.FS.readdirFiles(context, {
+            recursive: true
+        });
+        const stream = await docker.buildImage({
+            context,
+            src: files
+        }, {
+            t: tag,
+            labels,
+            dockerfile: src,
+            buildargs: buildArgs
+        });
+        return stream;
     }
-    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;
+    static async imageRm(name) {
+        const image = await docker.getImage(name);
+        if (!image) {
+            return;
+        }
+        await image.remove();
     }
-    await image.remove();
-  }
-  static async pullImage(tag) {
-    const isExists = await this.imageExists(tag);
-    if (isExists) {
-      return;
+    static async pullImage(tag) {
+        const isExists = await this.imageExists(tag);
+        if (isExists) {
+            return;
+        }
+        const stream = await docker.pull(tag, {});
+        await (0, followProgress_1.followProgress)(stream);
     }
-    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`] = {};
+    static async createContainer(options) {
+        const { name, tty, image, projectId, restart, extraHosts, networkMode, links = [], env = {}, volumes = [], ports = [], cmd = [] } = options;
+        const network = docker.getNetwork("workspace");
+        try {
+            await network.inspect();
         }
-        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
-          }
+        catch (err) {
+            if (err.statusCode === 404) {
+                await docker.createNetwork({
+                    Name: "workspace"
+                });
+            }
+        }
+        await this.pullImage(image);
+        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({
+                stream: true,
+                stdin: true,
+                stdout: true,
+                stderr: true
+            });
+            stdout.pipe(process.stdout);
         }
-      }
-    });
-  }
-  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;
     }
-    await container.start();
-    return container;
-  }
 }
-exports.Docker = Docker;
+exports.Docker = Docker;
+Docker.docker = docker;