@wocker/ws 1.0.26 → 1.0.28-beta.0

package/lib/modules/docker/index.js

@@ -1,45 +0,0 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtoService = exports.ModemService = exports.ImageService = exports.DockerService = exports.ContainerService = exports.ComposeService = exports.DockerModule = void 0;
-const core_1 = require("@wocker/core");
-const ComposeService_1 = require("./services/ComposeService");
-Object.defineProperty(exports, "ComposeService", { enumerable: true, get: function () { return ComposeService_1.ComposeService; } });
-const ContainerService_1 = require("./services/ContainerService");
-Object.defineProperty(exports, "ContainerService", { enumerable: true, get: function () { return ContainerService_1.ContainerService; } });
-const DockerService_1 = require("./services/DockerService");
-Object.defineProperty(exports, "DockerService", { enumerable: true, get: function () { return DockerService_1.DockerService; } });
-const ImageService_1 = require("./services/ImageService");
-Object.defineProperty(exports, "ImageService", { enumerable: true, get: function () { return ImageService_1.ImageService; } });
-const ModemService_1 = require("./services/ModemService");
-Object.defineProperty(exports, "ModemService", { enumerable: true, get: function () { return ModemService_1.ModemService; } });
-const ProtoService_1 = require("./services/ProtoService");
-Object.defineProperty(exports, "ProtoService", { enumerable: true, get: function () { return ProtoService_1.ProtoService; } });
-let DockerModule = class DockerModule {
-};
-exports.DockerModule = DockerModule;
-exports.DockerModule = DockerModule = __decorate([
-    (0, core_1.Module)({
-        providers: [
-            ComposeService_1.ComposeService,
-            ContainerService_1.ContainerService,
-            DockerService_1.DockerService,
-            ImageService_1.ImageService,
-            ModemService_1.ModemService,
-            ProtoService_1.ProtoService
-        ],
-        exports: [
-            ComposeService_1.ComposeService,
-            ContainerService_1.ContainerService,
-            DockerService_1.DockerService,
-            ImageService_1.ImageService,
-            ModemService_1.ModemService,
-            ProtoService_1.ProtoService
-        ]
-    })
-], DockerModule);

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

@@ -1,32 +0,0 @@
-import { LogService } from "@wocker/core";
-import { ComposeConfig } from "../type/ComposeConfig";
-type UpOptions = {
-    composefile: string;
-    context: string;
-};
-type DownOptions = {
-    composefile: string;
-    context: string;
-};
-type BuildOptions = {
-    composefile: string;
-    context: string;
-};
-type ExecOptions = {
-    service: string;
-    args: string[];
-    composefile: string;
-    context: string;
-};
-export declare class ComposeService {
-    protected readonly logService: LogService;
-    constructor(logService: LogService);
-    up(options: UpOptions): Promise<void>;
-    down(options: DownOptions): Promise<void>;
-    build(options: BuildOptions): Promise<void>;
-    exec(options: ExecOptions): Promise<void>;
-    protected getConfig(context: string, composefile: string): ComposeConfig;
-    protected getConfigAsString(context: string, composefile: string): string;
-    protected processChunk(chunk: Buffer<ArrayBufferLike>, streamSource?: "stdout" | "stderr"): void;
-}
-export {};

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

@@ -1,127 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-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 __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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.ComposeService = void 0;
-const core_1 = require("@wocker/core");
-const yaml_1 = __importDefault(require("yaml"));
-const compose = __importStar(require("docker-compose"));
-let ComposeService = class ComposeService {
-    constructor(logService) {
-        this.logService = logService;
-    }
-    async up(options) {
-        const { context, composefile } = options;
-        const res = await compose.upAll({
-            cwd: context,
-            configAsString: this.getConfigAsString(context, composefile),
-            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
-        });
-        this.logService.debug("compose up", res);
-    }
-    async down(options) {
-        const { context, composefile } = options;
-        const res = await compose.downAll({
-            cwd: context,
-            configAsString: this.getConfigAsString(context, composefile),
-            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
-        });
-        this.logService.debug("compose down", res);
-    }
-    async build(options) {
-        const { context, composefile } = options;
-        const res = await compose.buildAll({
-            cwd: context,
-            config: composefile,
-            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
-        });
-        this.logService.debug("build", res);
-    }
-    async exec(options) {
-        const { service, args, context, composefile } = options;
-        await compose.exec(service, args, {
-            configAsString: this.getConfigAsString(context, composefile),
-            callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)
-        });
-    }
-    getConfig(context, composefile) {
-        const fs = new core_1.FileSystem(context), config = fs.readYAML(composefile);
-        if (!config.networks) {
-            config.networks = {};
-        }
-        config.networks.workspace = {
-            external: true
-        };
-        for (const name in config.services) {
-            if (!config.services[name].networks) {
-                config.services[name].networks = [];
-            }
-            if (!config.services[name].networks.includes("workspace")) {
-                config.services[name].networks.push("workspace");
-            }
-        }
-        return config;
-    }
-    getConfigAsString(context, composefile) {
-        const config = this.getConfig(context, composefile);
-        return yaml_1.default.stringify(config);
-    }
-    processChunk(chunk, streamSource) {
-        switch (streamSource) {
-            case "stdout":
-                process.stdout.write(chunk);
-                break;
-            case "stderr":
-                process.stderr.write(chunk);
-                break;
-        }
-    }
-};
-exports.ComposeService = ComposeService;
-exports.ComposeService = ComposeService = __decorate([
-    (0, core_1.Injectable)("DOCKER_COMPOSE_SERVICE"),
-    __metadata("design:paramtypes", [core_1.LogService])
-], ComposeService);

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

@@ -1,14 +0,0 @@
-import { LogService, DockerServiceParams as Params } from "@wocker/core";
-import { Duplex } from "stream";
-import type Docker from "dockerode";
-import type { Container } from "dockerode";
-import { ModemService } from "./ModemService";
-export declare class ContainerService {
-    protected readonly logService: LogService;
-    protected readonly modemService: ModemService;
-    constructor(logService: LogService, modemService: ModemService);
-    get docker(): Docker;
-    get(name: string): Promise<Container>;
-    rm(name: string): Promise<void>;
-    exec(nameOrContainer: string | Container, options: Params.Exec | string[], _tty?: boolean): Promise<Duplex>;
-}

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

@@ -1,115 +0,0 @@
-"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/modules/docker/services/DockerService.d.ts

@@ -1,31 +0,0 @@
-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 modemService: ModemService;
-    protected readonly containerService: ContainerService;
-    protected readonly imageService: ImageService;
-    protected readonly logService: LogService;
-    constructor(modemService: ModemService, containerService: ContainerService, imageService: ImageService, logService: LogService);
-    get docker(): Docker;
-    createVolume(name: string): Promise<VolumeCreateResponse>;
-    hasVolume(name: string): Promise<boolean>;
-    getVolume(name: string): Promise<Volume>;
-    rmVolume(name: string): Promise<void>;
-    createContainer(params: Params.CreateContainer): Promise<Container>;
-    getContainer(name: string): Promise<Container | null>;
-    removeContainer(name: string): Promise<void>;
-    buildImage(params: Params.BuildImage): Promise<void>;
-    imageExists(tag: string): Promise<boolean>;
-    imageRm(tag: string, force?: boolean): Promise<void>;
-    imageLs(options?: Params.ImageList): Promise<Docker.ImageInfo[]>;
-    pullImage(tag: string): Promise<void>;
-    attach(containerOrName: string | Container): Promise<NodeJS.ReadWriteStream>;
-    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/modules/docker/services/DockerService.js

@@ -1,245 +0,0 @@
-"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.DockerService = void 0;
-const core_1 = require("@wocker/core");
-const ContainerService_1 = require("./ContainerService");
-const ModemService_1 = require("./ModemService");
-const ImageService_1 = require("./ImageService");
-let DockerService = class DockerService extends core_1.DockerService {
-    constructor(modemService, containerService, imageService, logService) {
-        super();
-        this.modemService = modemService;
-        this.containerService = containerService;
-        this.imageService = imageService;
-        this.logService = logService;
-    }
-    get docker() {
-        return this.modemService.docker;
-    }
-    async createVolume(name) {
-        return await this.docker.createVolume({
-            Name: name,
-            Driver: "local"
-        });
-    }
-    async hasVolume(name) {
-        const volume = await this.getVolume(name);
-        try {
-            await volume.inspect();
-            return true;
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async getVolume(name) {
-        return this.docker.getVolume(name);
-    }
-    async rmVolume(name) {
-        const volume = await this.getVolume(name);
-        await volume.remove();
-    }
-    async createContainer(params) {
-        const { name, user, entrypoint, tty, image, projectId, restart, memory, memorySwap, ulimits, extraHosts, networkMode = "bridge", links = [], env = {}, volumes = [], ports = [], cmd = [], network: networkName = "workspace", aliases } = params;
-        const network = this.docker.getNetwork(networkName);
-        try {
-            await network.inspect();
-        }
-        catch (err) {
-            if (err.statusCode === 404) {
-                await this.docker.createNetwork({
-                    Name: networkName
-                });
-            }
-        }
-        await this.pullImage(image);
-        return this.docker.createContainer({
-            name,
-            User: user,
-            Image: image,
-            Hostname: name,
-            Labels: {
-                ...projectId ? { projectId } : {}
-            },
-            AttachStdin: true,
-            AttachStdout: true,
-            AttachStderr: true,
-            OpenStdin: true,
-            StdinOnce: false,
-            Entrypoint: entrypoint,
-            Tty: true,
-            Cmd: cmd,
-            Env: Object.keys(env).map((key) => {
-                const value = env[key];
-                return `${key}=${value}`;
-            }),
-            ExposedPorts: ports.reduce((res, value) => {
-                const [, , containerPort, type = "tcp"] = /(\d+):(\d+)(?:\/(\w+))?/.exec(value) || [];
-                if (containerPort) {
-                    res[`${containerPort}/${type}`] = {};
-                }
-                return res;
-            }, {}),
-            HostConfig: {
-                Memory: memory,
-                MemorySwap: memorySwap,
-                NetworkMode: networkMode,
-                ExtraHosts: extraHosts,
-                Ulimits: ulimits ? Object.keys(ulimits).reduce((res, name) => {
-                    return [
-                        ...res,
-                        {
-                            Name: name,
-                            Hard: ulimits[name].hard,
-                            Soft: ulimits[name].soft
-                        }
-                    ];
-                }, []) : [],
-                ...restart ? {
-                    RestartPolicy: {
-                        Name: restart
-                    }
-                } : {},
-                Binds: volumes,
-                PortBindings: ports.reduce((res, value) => {
-                    const [, hostPort, containerPort, type = "tcp"] = /(\d+):(\d+)(?:\/(\w+))?/.exec(value) || [];
-                    if (hostPort && containerPort) {
-                        res[`${containerPort}/${type}`] = [
-                            { HostPort: hostPort }
-                        ];
-                    }
-                    else {
-                        this.logService.warn(`Invalid port format for container "${name}": "${value}". Expected format: hostPort:containerPort[/protocol]`);
-                    }
-                    return res;
-                }, {})
-            },
-            NetworkingConfig: {
-                EndpointsConfig: networkMode === "host" ? {} : {
-                    [networkName]: {
-                        Links: links,
-                        Aliases: aliases || (env.VIRTUAL_HOST ? env.VIRTUAL_HOST.split(",") : undefined)
-                    }
-                }
-            }
-        });
-    }
-    async getContainer(name) {
-        return this.containerService.get(name);
-    }
-    async removeContainer(name) {
-        await this.containerService.rm(name);
-    }
-    async buildImage(params) {
-        await this.imageService.build(params);
-    }
-    async imageExists(tag) {
-        return this.imageService.exists(tag);
-    }
-    async imageRm(tag, force = false) {
-        await this.imageService.rm(tag, force);
-    }
-    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 this.docker.listImages({
-            filters: JSON.stringify(filters)
-        });
-    }
-    async pullImage(tag) {
-        await this.imageService.pull(tag);
-    }
-    async attach(containerOrName) {
-        let container = typeof containerOrName === "string"
-            ? await this.getContainer(containerOrName)
-            : containerOrName;
-        if (!container) {
-            return;
-        }
-        const stream = await container.attach({
-            stream: true,
-            hijack: true,
-            stdin: true,
-            stdout: true,
-            stderr: true,
-            logs: true,
-            detachKeys: "ctrl-d"
-        });
-        await this.attachStream(stream);
-        const handleResize = () => {
-            const [width, height] = process.stdout.getWindowSize();
-            container.resize({
-                w: width,
-                h: height
-            });
-        };
-        process.stdout.on("resize", handleResize);
-        handleResize();
-        return stream;
-    }
-    async attachStream(stream) {
-        return this.modemService.attachStream(stream);
-    }
-    async exec(nameOrContainer, options, _tty) {
-        return await this.containerService.exec(nameOrContainer, options, _tty);
-    }
-    async logs(containerOrName) {
-        const container = typeof containerOrName === "string"
-            ? await this.getContainer(containerOrName)
-            : containerOrName;
-        if (!container) {
-            return;
-        }
-        const stream = await container.logs({
-            stdout: true,
-            stderr: true,
-            follow: true,
-            tail: 4
-        });
-        stream.on("data", (data) => {
-            process.stdout.write(data);
-        });
-        stream.on("error", (data) => {
-            process.stderr.write(data);
-        });
-        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", [ModemService_1.ModemService,
-        ContainerService_1.ContainerService,
-        ImageService_1.ImageService,
-        core_1.LogService])
-], DockerService);

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

@@ -1,12 +0,0 @@
-import type Docker from "dockerode";
-import { DockerServiceParams as Params } from "@wocker/core";
-import { ModemService } from "./ModemService";
-export declare class ImageService {
-    protected readonly modemService: ModemService;
-    constructor(modemService: ModemService);
-    get docker(): Docker;
-    build(params: Params.BuildImage): Promise<void>;
-    exists(tag: string): Promise<boolean>;
-    pull(tag: string): Promise<void>;
-    rm(tag: string, force?: boolean): Promise<void>;
-}