@wocker/ws 1.0.21 → 1.0.23

package/lib/makes/Plugin.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const core_1 = require("@wocker/core");
+class Plugin {
+    constructor(type) {
+        this.type = type;
+        const pluginName = Reflect.getMetadata(core_1.PLUGIN_NAME_METADATA, this.type);
+        if (!pluginName || typeof pluginName !== "string") {
+            throw new Error("Invalid plugin package");
+        }
+        this.name = pluginName;
+    }
+}
+exports.Plugin = Plugin;

package/lib/makes/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./FS";
 export * from "./Http";
 export * from "./Logger";
+export * from "./Plugin";

package/lib/makes/index.js

@@ -14,6 +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("./FS"), exports);
 __exportStar(require("./Http"), exports);
 __exportStar(require("./Logger"), exports);
+__exportStar(require("./Plugin"), exports);

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

@@ -0,0 +1,2 @@
+export declare class AppModule {
+}

package/lib/{plugins/proxmox → modules/app}/index.js

@@ -6,18 +6,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProxmoxPlugin = void 0;
+exports.AppModule = void 0;
 const core_1 = require("@wocker/core");
-const ProxmoxController_1 = require("./controllers/ProxmoxController");
-let ProxmoxPlugin = class ProxmoxPlugin {
+let AppModule = class AppModule {
 };
-exports.ProxmoxPlugin = ProxmoxPlugin;
-exports.ProxmoxPlugin = ProxmoxPlugin = __decorate([
-    (0, core_1.Plugin)({
-        name: "proxmox",
-        controllers: [
-            ProxmoxController_1.ProxmoxController
-        ],
-        providers: []
-    })
-], ProxmoxPlugin);
+exports.AppModule = AppModule;
+exports.AppModule = AppModule = __decorate([
+    (0, core_1.Module)({})
+], AppModule);

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

@@ -0,0 +1,8 @@
+import { ContainerService } from "./services/ContainerService";
+import { ImageService } from "./services/ImageService";
+import { DockerService } from "./services/DockerService";
+import { ModemService } from "./services/ModemService";
+import { ProtoService } from "./services/ProtoService";
+export declare class DockerModule {
+}
+export { ContainerService, ImageService, DockerService, ModemService, ProtoService };

package/lib/modules/docker/index.js

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

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

@@ -0,0 +1,14 @@
+import { LogService, DockerServiceParams as Params } from "@wocker/core";
+import type Docker from "dockerode";
+import { Duplex } from "stream";
+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

@@ -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({
@@ -183,34 +153,23 @@ let DockerService = class DockerService extends core_1.DockerService {
             t: tag,
             labels,
             buildargs: Object.keys(buildArgs).reduce((res, key) => {
-                res[key] = typeof buildArgs[key] !== "string"
-                    ? buildArgs[key].toString()
-                    : buildArgs[key];
+                const value = buildArgs[key];
+                if (typeof value !== "undefined") {
+                    res[key] = typeof buildArgs[key] !== "string"
+                        ? buildArgs[key].toString()
+                        : buildArgs[key];
+                }
                 return res;
             }, {}),
             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 || {};
@@ -238,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"
@@ -274,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"
@@ -344,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>;
+}