@wocker/ws 1.0.22 → 1.0.23

package/lib/modules/docker/services/ContainerService.js

@@ -0,0 +1,115 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerService = void 0;
+const core_1 = require("@wocker/core");
+const ModemService_1 = require("./ModemService");
+let ContainerService = class ContainerService {
+    constructor(logService, modemService) {
+        this.logService = logService;
+        this.modemService = modemService;
+    }
+    get docker() {
+        return this.modemService.docker;
+    }
+    async get(name) {
+        const containers = await this.docker.listContainers({
+            all: true,
+            filters: {
+                name: [name]
+            }
+        });
+        const container = containers.find((container) => {
+            return container.Names.indexOf("/" + name) >= 0;
+        });
+        if (!container) {
+            return null;
+        }
+        return this.docker.getContainer(container.Id);
+    }
+    async rm(name) {
+        const container = await this.get(name);
+        if (!container) {
+            return;
+        }
+        const { State: { Status } } = await container.inspect();
+        if (Status === "running" || Status === "restarting") {
+            try {
+                await container.stop();
+            }
+            catch (err) {
+                this.logService.error("DockerService.removeContainer", err.message);
+            }
+        }
+        try {
+            await container.remove();
+        }
+        catch (err) {
+            this.logService.error("DockerService.removeContainer: ", err.message);
+        }
+    }
+    async exec(nameOrContainer, options, _tty) {
+        const container = typeof nameOrContainer === "string"
+            ? await this.get(nameOrContainer)
+            : nameOrContainer;
+        if (!container) {
+            return;
+        }
+        const { cmd = [], tty = false, user } = Array.isArray(options) ? {
+            cmd: options,
+            tty: _tty
+        } : options;
+        const exec = await container.exec({
+            AttachStdin: true,
+            AttachStdout: true,
+            AttachStderr: true,
+            Tty: tty,
+            User: user,
+            Cmd: cmd,
+            ConsoleSize: [
+                process.stdout.rows,
+                process.stdout.columns
+            ]
+        });
+        const stream = await exec.start({
+            hijack: true,
+            stdin: tty,
+            Tty: tty
+        });
+        if (tty) {
+            const handleResize = async () => {
+                const [width, height] = process.stdout.getWindowSize();
+                this.logService.debug("Exec resize", {
+                    width,
+                    height
+                });
+                await exec.resize({
+                    w: width,
+                    h: height
+                });
+            };
+            process.on("SIGWINCH", handleResize);
+            try {
+                await this.modemService.attachStream(stream);
+            }
+            finally {
+                process.off("SIGWINCH", handleResize);
+            }
+        }
+        return stream;
+    }
+};
+exports.ContainerService = ContainerService;
+exports.ContainerService = ContainerService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.LogService,
+        ModemService_1.ModemService])
+], ContainerService);

package/lib/{services → modules/docker/services}/DockerService.d.ts

@@ -1,10 +1,16 @@
-import { DockerService as CoreDockerService, DockerServiceParams as Params } from "@wocker/core";
-import Docker, { Container, Volume, VolumeCreateResponse } from "dockerode";
-import { LogService } from "./LogService";
+import { DockerService as CoreDockerService, DockerServiceParams as Params, LogService } from "@wocker/core";
+import type Docker from "dockerode";
+import type { Container, Volume, VolumeCreateResponse } from "dockerode";
+import { ContainerService } from "./ContainerService";
+import { ModemService } from "./ModemService";
+import { ImageService } from "./ImageService";
 export declare class DockerService extends CoreDockerService {
     protected readonly logService: LogService;
-    protected docker: Docker;
-    constructor(logService: LogService);
+    protected readonly modemService: ModemService;
+    protected readonly containerService: ContainerService;
+    protected readonly imageService: ImageService;
+    constructor(logService: LogService, modemService: ModemService, containerService: ContainerService, imageService: ImageService);
+    get docker(): Docker;
     createVolume(name: string): Promise<VolumeCreateResponse>;
     hasVolume(name: string): Promise<boolean>;
     getVolume(name: string): Promise<Volume>;
@@ -21,4 +27,5 @@ export declare class DockerService extends CoreDockerService {
     attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;
     exec(nameOrContainer: string | Container, options: Params.Exec | string[], _tty?: boolean): Promise<import("stream").Duplex>;
     logs(containerOrName: string | Container): Promise<NodeJS.ReadableStream>;
+    followProgress(stream: NodeJS.ReadableStream): Promise<void>;
 }

package/lib/{services → modules/docker/services}/DockerService.js

@@ -8,23 +8,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerService = void 0;
 const core_1 = require("@wocker/core");
-const dockerode_1 = __importDefault(require("dockerode"));
-const utils_1 = require("../utils");
-const makes_1 = require("../makes");
-const LogService_1 = require("./LogService");
+const ContainerService_1 = require("./ContainerService");
+const ModemService_1 = require("./ModemService");
+const ImageService_1 = require("./ImageService");
 let DockerService = class DockerService extends core_1.DockerService {
-    constructor(logService) {
+    constructor(logService, modemService, containerService, imageService) {
         super();
         this.logService = logService;
-        this.docker = new dockerode_1.default({
-            socketPath: "/var/run/docker.sock"
-        });
+        this.modemService = modemService;
+        this.containerService = containerService;
+        this.imageService = imageService;
+    }
+    get docker() {
+        return this.modemService.docker;
     }
     async createVolume(name) {
         return await this.docker.createVolume({
@@ -136,44 +135,15 @@ let DockerService = class DockerService extends core_1.DockerService {
         });
     }
     async getContainer(name) {
-        const containers = await this.docker.listContainers({
-            all: true,
-            filters: {
-                name: [name]
-            }
-        });
-        const container = containers.find((container) => {
-            return container.Names.indexOf("/" + name) >= 0;
-        });
-        if (container) {
-            return this.docker.getContainer(container.Id);
-        }
-        return null;
+        return this.containerService.get(name);
     }
     async removeContainer(name) {
-        const container = await this.getContainer(name);
-        if (!container) {
-            return;
-        }
-        const { State: { Status } } = await container.inspect();
-        if (Status === "running" || Status === "restarting") {
-            try {
-                await container.stop();
-            }
-            catch (err) {
-                makes_1.Logger.error("DockerService.removeContainer", err.message);
-            }
-        }
-        try {
-            await container.remove();
-        }
-        catch (err) {
-            makes_1.Logger.error("DockerService.removeContainer: ", err.message);
-        }
+        await this.containerService.rm(name);
     }
     async buildImage(params) {
         const { tag, labels = {}, buildArgs = {}, context, src } = params;
-        const files = await makes_1.FS.readdirFiles(context, {
+        const fs = new core_1.FileSystem(context);
+        const files = await fs.readdirFiles("", {
             recursive: true
         });
         const stream = await this.docker.buildImage({
@@ -193,27 +163,13 @@ let DockerService = class DockerService extends core_1.DockerService {
             }, {}),
             dockerfile: src
         });
-        await (0, utils_1.followProgress)(stream);
+        await this.modemService.followProgress(stream);
     }
     async imageExists(tag) {
-        const image = this.docker.getImage(tag);
-        try {
-            await image.inspect();
-            return true;
-        }
-        catch (ignore) {
-            return false;
-        }
+        return this.imageService.exists(tag);
     }
     async imageRm(tag, force = false) {
-        const image = this.docker.getImage(tag);
-        const exists = await this.imageExists(tag);
-        if (!exists) {
-            return;
-        }
-        await image.remove({
-            force
-        });
+        await this.imageService.rm(tag, force);
     }
     async imageLs(options) {
         const { tag, reference, labels } = options || {};
@@ -241,12 +197,7 @@ let DockerService = class DockerService extends core_1.DockerService {
         });
     }
     async pullImage(tag) {
-        const exists = await this.imageExists(tag);
-        if (exists) {
-            return;
-        }
-        const stream = await this.docker.pull(tag);
-        await (0, utils_1.followProgress)(stream);
+        await this.imageService.pull(tag);
     }
     async attach(containerOrName) {
         let container = typeof containerOrName === "string"
@@ -277,54 +228,10 @@ let DockerService = class DockerService extends core_1.DockerService {
         return stream;
     }
     async attachStream(stream) {
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-        }
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-        process.stdin.pipe(stream);
-        stream.setEncoding("utf8");
-        stream.pipe(process.stdout);
-        const onEnd = () => {
-            process.stdin.pause();
-            if (process.stdin.isTTY) {
-                process.stdin.setRawMode(false);
-            }
-            process.stdin.unpipe(stream);
-            stream.unpipe(process.stdout);
-        };
-        stream.on("end", onEnd);
-        stream.on("error", onEnd);
-        return stream;
+        return this.modemService.attachStream(stream);
     }
     async exec(nameOrContainer, options, _tty) {
-        const container = typeof nameOrContainer === "string"
-            ? await this.getContainer(nameOrContainer)
-            : nameOrContainer;
-        if (!container) {
-            return;
-        }
-        const { cmd = [], tty = false, user } = Array.isArray(options) ? {
-            cmd: options,
-            tty: _tty
-        } : options;
-        const exec = await container.exec({
-            AttachStdin: true,
-            AttachStdout: true,
-            AttachStderr: tty,
-            Tty: tty,
-            User: user,
-            Cmd: cmd
-        });
-        const stream = await exec.start({
-            hijack: true,
-            stdin: tty,
-            Tty: tty
-        });
-        if (tty) {
-            await this.attachStream(stream);
-        }
-        return stream;
+        return await this.containerService.exec(nameOrContainer, options, _tty);
     }
     async logs(containerOrName) {
         const container = typeof containerOrName === "string"
@@ -347,9 +254,15 @@ let DockerService = class DockerService extends core_1.DockerService {
         });
         return stream;
     }
+    async followProgress(stream) {
+        await this.modemService.followProgress(stream);
+    }
 };
 exports.DockerService = DockerService;
 exports.DockerService = DockerService = __decorate([
     (0, core_1.Injectable)("DOCKER_SERVICE"),
-    __metadata("design:paramtypes", [LogService_1.LogService])
+    __metadata("design:paramtypes", [core_1.LogService,
+        ModemService_1.ModemService,
+        ContainerService_1.ContainerService,
+        ImageService_1.ImageService])
 ], DockerService);

package/lib/modules/docker/services/ImageService.d.ts

@@ -0,0 +1,18 @@
+import type Docker from "dockerode";
+import { ModemService } from "./ModemService";
+type BuildParams = {
+    tag: string;
+    context: string;
+    dockerfile: string;
+    version: "1" | "2";
+};
+export declare class ImageService {
+    protected readonly modemService: ModemService;
+    constructor(modemService: ModemService);
+    get docker(): Docker;
+    build(params: BuildParams): Promise<void>;
+    exists(tag: string): Promise<boolean>;
+    pull(tag: string): Promise<void>;
+    rm(tag: string, force?: boolean): Promise<void>;
+}
+export {};

package/lib/modules/docker/services/ImageService.js

@@ -0,0 +1,68 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageService = void 0;
+const core_1 = require("@wocker/core");
+const ModemService_1 = require("./ModemService");
+let ImageService = class ImageService {
+    constructor(modemService) {
+        this.modemService = modemService;
+    }
+    get docker() {
+        return this.modemService.docker;
+    }
+    async build(params) {
+        const { tag, context, dockerfile, version } = params;
+        const files = (new core_1.FileSystem(context)).readdir("", {
+            recursive: true
+        });
+        const stream = await this.docker.buildImage({
+            context,
+            src: files
+        }, {
+            t: tag,
+            dockerfile,
+            version
+        });
+        await this.modemService.followProgress(stream);
+    }
+    async exists(tag) {
+        const image = this.docker.getImage(tag);
+        try {
+            await image.inspect();
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async pull(tag) {
+        if (await this.exists(tag)) {
+            return;
+        }
+        const stream = await this.docker.pull(tag);
+        await this.modemService.followProgress(stream);
+    }
+    async rm(tag, force = false) {
+        if (!await this.exists(tag)) {
+            return;
+        }
+        const image = this.docker.getImage(tag);
+        await image.remove({
+            force
+        });
+    }
+};
+exports.ImageService = ImageService;
+exports.ImageService = ImageService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [ModemService_1.ModemService])
+], ImageService);

package/lib/modules/docker/services/ModemService.d.ts

@@ -0,0 +1,14 @@
+import { ModemService as CoreModemService } from "@wocker/core";
+import type Modem from "docker-modem";
+import type Docker from "dockerode";
+import { ProtoService } from "./ProtoService";
+export declare class ModemService extends CoreModemService {
+    protected readonly protoService: ProtoService;
+    protected _modem?: Modem;
+    protected _docker?: Docker;
+    constructor(protoService: ProtoService);
+    get modem(): Modem;
+    get docker(): Docker;
+    attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;
+    followProgress(stream: NodeJS.ReadableStream): Promise<void>;
+}

package/lib/modules/docker/services/ModemService.js

@@ -0,0 +1,137 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModemService = void 0;
+const core_1 = require("@wocker/core");
+const formatSizeUnits_1 = require("../utils/formatSizeUnits");
+const ProtoService_1 = require("./ProtoService");
+let ModemService = class ModemService extends core_1.ModemService {
+    constructor(protoService) {
+        super();
+        this.protoService = protoService;
+    }
+    get modem() {
+        if (!this._modem) {
+            const Modem = require("docker-modem");
+            this._modem = new Modem({
+                socketPath: "/var/run/docker.sock"
+            });
+        }
+        return this._modem;
+    }
+    get docker() {
+        if (!this._docker) {
+            const Docker = require("dockerode");
+            this._docker = new Docker({
+                modem: this.modem
+            });
+        }
+        return this._docker;
+    }
+    async attachStream(stream) {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.pipe(stream);
+        stream.setEncoding("utf8");
+        stream.pipe(process.stdout);
+        try {
+            await new Promise((resolve, reject) => {
+                stream.on("end", resolve);
+                stream.on("error", reject);
+            });
+        }
+        finally {
+            process.stdin.pause();
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.unpipe(stream);
+            stream.unpipe(process.stdout);
+        }
+        return stream;
+    }
+    async followProgress(stream) {
+        let isEnded = false, line = 0;
+        const mapLines = {};
+        return new Promise((resolve, reject) => {
+            const handleEnd = () => {
+                if (!isEnded) {
+                    resolve();
+                }
+                isEnded = true;
+            };
+            stream.on("data", (chunk) => {
+                const text = chunk.toString().replace(/}\s*\{/g, "},{"), items = JSON.parse(`[${text}]`);
+                for (const item of items) {
+                    if (item.id === "moby.buildkit.trace") {
+                    }
+                    if (item.stream) {
+                        process.stdout.write(`${item.stream}`);
+                        line += item.stream.split("\n").length - 1;
+                    }
+                    else if (item.id) {
+                        const { id, status, processDetail: { current, total, } = {} } = item;
+                        if (typeof mapLines[id] === "undefined") {
+                            mapLines[id] = line;
+                        }
+                        const targetLine = typeof mapLines[id] !== "undefined"
+                            ? mapLines[id]
+                            : line;
+                        const dy = line - targetLine;
+                        if (dy > 0) {
+                            process.stdout.write("\x1b[s");
+                            process.stdout.write(`\x1b[${dy}A`);
+                        }
+                        process.stdout.write("\x1b[2K");
+                        let str = `${id}: ${status}\n`;
+                        if (status === "Downloading") {
+                            const width = process.stdout.columns;
+                            const sizeWidth = 19, totalWidth = width - id.length - status.length - sizeWidth - 7, currentWidth = Math.floor(totalWidth * (current / total)), formatSize = `${(0, formatSizeUnits_1.formatSizeUnits)(current)}/${(0, formatSizeUnits_1.formatSizeUnits)(total)}`;
+                            str = `${id}: ${status} [${"█".repeat(currentWidth)}${"░".repeat(totalWidth - currentWidth)}] ${formatSize}\n`;
+                        }
+                        process.stdout.write(str);
+                        if (dy > 0) {
+                            process.stdout.write("\x1b[u");
+                        }
+                        else {
+                            line++;
+                        }
+                    }
+                    else if (typeof item.aux === "object") {
+                        const str = `auxID: ${item.aux.ID}`;
+                        process.stdout.write(`${str}\n`);
+                        line += Math.ceil(str.length / process.stdout.columns);
+                    }
+                    else if (item.status) {
+                        process.stdout.write(`${item.status}\n`);
+                        line += Math.ceil(item.status.length / process.stdout.columns);
+                    }
+                    else {
+                        console.info("Unexpected data", item);
+                    }
+                }
+            });
+            stream.on("end", handleEnd);
+            stream.on("close", handleEnd);
+            stream.on("error", (err) => {
+                reject(err);
+            });
+        });
+    }
+};
+exports.ModemService = ModemService;
+exports.ModemService = ModemService = __decorate([
+    (0, core_1.Injectable)("MODEM_SERVICE"),
+    __metadata("design:paramtypes", [ProtoService_1.ProtoService])
+], ModemService);

package/lib/modules/docker/services/ProtoService.d.ts

@@ -0,0 +1,6 @@
+import { Type, Root } from "protobufjs";
+export declare class ProtoService {
+    protected _root?: Root;
+    get root(): Root;
+    lookupType(path: string): Type;
+}

package/lib/modules/docker/services/ProtoService.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtoService = void 0;
+const protobufjs_1 = require("protobufjs");
+const env_1 = require("../../../env");
+class ProtoService {
+    get root() {
+        if (!this._root) {
+            this._root = (0, protobufjs_1.loadSync)([
+                `${env_1.ROOT_DIR}/proto/solver/pb/ops.proto`,
+                `${env_1.ROOT_DIR}/proto/buildkit.proto`
+            ]);
+        }
+        return this._root;
+    }
+    lookupType(path) {
+        return this.root.lookupType(path);
+    }
+}
+exports.ProtoService = ProtoService;

package/lib/modules/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./docker";
+export * from "./keystore";
+export * from "./proxy";

package/lib/{keystore → modules}/index.js

@@ -14,4 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./KeystoreService"), exports);
+__exportStar(require("./docker"), exports);
+__exportStar(require("./keystore"), exports);
+__exportStar(require("./proxy"), exports);

package/lib/{controllers → modules/keystore/controllers}/KeystoreController.d.ts

@@ -1,5 +1,5 @@
-import { AppConfigService } from "../services";
-import { KeystoreService } from "../keystore";
+import { AppConfigService } from "../../../services/AppConfigService";
+import { KeystoreService } from "../services/KeystoreService";
 export declare class KeystoreController {
     protected readonly appConfigService: AppConfigService;
     protected readonly keystoreService: KeystoreService;

package/lib/{controllers → modules/keystore/controllers}/KeystoreController.js

@@ -15,8 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeystoreController = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
-const services_1 = require("../services");
-const keystore_1 = require("../keystore");
+const AppConfigService_1 = require("../../../services/AppConfigService");
+const KeystoreService_1 = require("../services/KeystoreService");
 let KeystoreController = class KeystoreController {
     constructor(appConfigService, keystoreService) {
         this.appConfigService = appConfigService;
@@ -34,7 +34,7 @@ let KeystoreController = class KeystoreController {
             return;
         }
         this.appConfigService.config.keystore = provider;
-        this.appConfigService.config.save();
+        this.appConfigService.save();
     }
     async add(name, provider) {
         const value = await (0, utils_1.promptInput)({
@@ -101,6 +101,6 @@ __decorate([
 exports.KeystoreController = KeystoreController = __decorate([
     (0, core_1.Controller)(),
     (0, core_1.Description)("Keystore commands"),
-    __metadata("design:paramtypes", [services_1.AppConfigService,
-        keystore_1.KeystoreService])
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        KeystoreService_1.KeystoreService])
 ], KeystoreController);

package/lib/modules/keystore/index.d.ts

@@ -0,0 +1,4 @@
+import { KeystoreService } from "./services/KeystoreService";
+export declare class KeystoreModule {
+}
+export { KeystoreService };