@wocker/ws 1.0.1 → 1.0.3

package/lib/services/AppEventsService.js

@@ -1,29 +1,30 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppEventsService = void 0;
-var _events = require("events");
-class AppEventsService {
-  emitter = new _events.EventEmitter();
-  handles = {};
-  on(event, handle) {
-    this.handles[event] = [...(this.handles[event] || []), handle];
-    return () => {
-      this.handles[event] = this.handles[event].filter(filterHandle => {
-        return filterHandle !== handle;
-      });
-    };
-  }
-  off(event, handle) {
-    //
-  }
-  async emit(event, ...args) {
-    const handles = this.handles[event] || [];
-    for (const i in handles) {
-      await handles[i](...args);
+const core_1 = require("@wocker/core");
+class AppEventsService extends core_1.AppEventsService {
+    constructor() {
+        super(...arguments);
+        this.handles = {};
+    }
+    on(event, handle) {
+        this.handles[event] = [
+            ...this.handles[event] || [],
+            handle
+        ];
+        return () => {
+            this.handles[event] = this.handles[event].filter((filterHandle) => {
+                return filterHandle !== handle;
+            });
+        };
+    }
+    off(event, handle) {
+    }
+    async emit(event, ...args) {
+        const handles = this.handles[event] || [];
+        for (const i in handles) {
+            await handles[i](...args);
+        }
     }
-  }
 }
-exports.AppEventsService = AppEventsService;
+exports.AppEventsService = AppEventsService;

package/lib/services/DockerService.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import Docker, { Container } from "dockerode";
+import { DI } from "../makes";
+declare namespace Params {
+    type CreateContainer = {
+        name: string;
+        image: string;
+        restart?: "always";
+        projectId?: string;
+        tty?: boolean;
+        ulimits?: {
+            [key: string]: {
+                hard?: number;
+                soft?: number;
+            };
+        };
+        links?: string[];
+        env?: {
+            [key: string]: string;
+        };
+        networkMode?: string;
+        extraHosts?: any;
+        volumes?: string[];
+        ports?: string[];
+        cmd?: string[];
+    };
+    type BuildImage = {
+        tag: string;
+        buildArgs?: {
+            [key: string]: string;
+        };
+        labels?: {
+            [key: string]: string;
+        };
+        context: string;
+        src: string;
+    };
+}
+declare class DockerService {
+    protected docker: Docker;
+    constructor(di: DI);
+    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): Promise<void>;
+    pullImage(tag: string): Promise<void>;
+    attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
+}
+export { DockerService };

package/lib/services/DockerService.js

@@ -0,0 +1,200 @@
+"use strict";
+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 dockerode_1 = __importDefault(require("dockerode"));
+const utils_1 = require("../utils");
+const makes_1 = require("../makes");
+class DockerService {
+    constructor(di) {
+        this.docker = new dockerode_1.default({
+            socketPath: "/var/run/docker.sock"
+        });
+    }
+    async createContainer(params) {
+        const { name, tty, image, projectId, restart, ulimits, extraHosts, networkMode, links = [], env = {}, volumes = [], ports = [], cmd = [] } = params;
+        const network = this.docker.getNetwork("workspace");
+        try {
+            await network.inspect();
+        }
+        catch (err) {
+            if (err.statusCode === 404) {
+                await this.docker.createNetwork({
+                    Name: "workspace"
+                });
+            }
+        }
+        await this.pullImage(image);
+        return this.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,
+                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] = /(\d+):(\d+)/.exec(value) || [];
+                    if (hostPort && containerPort) {
+                        res[`${containerPort}/tcp`] = [
+                            { HostPort: hostPort }
+                        ];
+                    }
+                    return res;
+                }, {}),
+            },
+            NetworkingConfig: {
+                EndpointsConfig: networkMode === "host" ? {} : {
+                    workspace: {
+                        Links: links
+                    }
+                }
+            }
+        });
+    }
+    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;
+    }
+    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);
+        }
+    }
+    async buildImage(params) {
+        const { tag, labels = {}, buildArgs = {}, context, src } = params;
+        const files = await makes_1.FS.readdirFiles(context, {
+            recursive: true
+        });
+        const stream = await this.docker.buildImage({
+            context,
+            src: files
+        }, {
+            t: tag,
+            labels,
+            buildargs: Object.keys(buildArgs).reduce((res, key) => {
+                res[key] = typeof buildArgs[key] !== "string"
+                    ? buildArgs[key].toString()
+                    : buildArgs[key];
+                return res;
+            }, {}),
+            dockerfile: src
+        });
+        await (0, utils_1.followProgress)(stream);
+    }
+    async imageExists(tag) {
+        const image = this.docker.getImage(tag);
+        try {
+            await image.inspect();
+            return true;
+        }
+        catch (ignore) {
+            return false;
+        }
+    }
+    async imageRm(tag) {
+        const image = await this.docker.getImage(tag);
+        if (!image) {
+            return;
+        }
+        await image.remove();
+    }
+    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);
+    }
+    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);
+        });
+    }
+}
+exports.DockerService = DockerService;

package/lib/services/LogService.d.ts

@@ -0,0 +1,12 @@
+import { DI } from "../makes";
+import { AppConfigService } from "./AppConfigService";
+declare class LogService {
+    protected appConfigService: AppConfigService;
+    constructor(di: DI);
+    log(...data: any[]): void;
+    info(...data: any[]): void;
+    warn(...data: any[]): void;
+    error(...data: any[]): void;
+    protected _log(type: string, ...data: any[]): void;
+}
+export { LogService };

package/lib/services/LogService.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogService = void 0;
+const format_1 = __importDefault(require("date-fns/format"));
+const makes_1 = require("../makes");
+const AppConfigService_1 = require("./AppConfigService");
+class LogService {
+    constructor(di) {
+        this.appConfigService = di.resolveService(AppConfigService_1.AppConfigService);
+    }
+    log(...data) {
+        this._log("log", ...data);
+    }
+    info(...data) {
+        this._log("info", ...data);
+    }
+    warn(...data) {
+        this._log("warn", ...data);
+    }
+    error(...data) {
+        this._log("error", ...data);
+    }
+    _log(type, ...data) {
+        const time = (0, format_1.default)(new Date(), "yyyy-MM-dd hh:mm:ss");
+        const logPath = this.appConfigService.dataPath("ws.log");
+        const logData = data.map((item) => {
+            return typeof item !== "string" ? JSON.stringify(item) : item;
+        }).join(" ");
+        if (!makes_1.FS.existsSync(logPath)) {
+            makes_1.FS.writeFileSync(logPath, "");
+        }
+        makes_1.FS.appendFileSync(logPath, `[${time}] ${type}: ${logData}\n`);
+    }
+}
+exports.LogService = LogService;

package/lib/services/PluginService.d.ts

@@ -0,0 +1,11 @@
+import { Cli } from "@wocker/core";
+import { DI, Controller } from "../makes";
+declare class PluginService {
+    protected di: DI;
+    protected cli: Cli;
+    constructor(di: DI);
+    use(Constructor: {
+        new (...params: any[]): Controller;
+    }): void;
+}
+export { PluginService };

package/lib/services/PluginService.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginService = void 0;
+const core_1 = require("@wocker/core");
+class PluginService {
+    constructor(di) {
+        this.di = di;
+        this.cli = di.resolveService(core_1.Cli);
+    }
+    use(Constructor) {
+        const controller = new Constructor(this.di);
+        controller.install(this.cli);
+    }
+}
+exports.PluginService = PluginService;

package/lib/services/PresetService.d.ts

@@ -0,0 +1,14 @@
+import { EnvConfig } from "../types";
+import { DI, Preset } from "../makes";
+type SearchOptions = Partial<{
+    name: string;
+}>;
+declare class PresetService {
+    constructor(di: DI);
+    getImageName(preset: Preset, buildArgs?: EnvConfig): string;
+    save(preset: Preset): Promise<void>;
+    get(name: string): Promise<Preset>;
+    search(options?: SearchOptions): Promise<Preset[]>;
+    searchOne(options?: SearchOptions): Promise<Preset | null>;
+}
+export { PresetService, SearchOptions as PresetServiceSearchOptions };

package/lib/services/PresetService.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresetService = void 0;
+const md5_1 = __importDefault(require("md5"));
+const env_1 = require("../env");
+const makes_1 = require("../makes");
+class PresetService {
+    constructor(di) { }
+    getImageName(preset, buildArgs = {}) {
+        const rawValues = [];
+        const hashValues = [];
+        Object.keys(preset.buildArgsOptions || {}).forEach((key) => {
+            const hash = (preset.buildArgsOptions[key] || {}).hash || true;
+            const value = buildArgs[key];
+            if (hash) {
+                hashValues.push(value);
+            }
+            else {
+                rawValues.push(value);
+            }
+        });
+        const version = [
+            ...rawValues,
+            (0, md5_1.default)(hashValues.join(",")).substr(0, 6)
+        ].filter((value) => {
+            return !!value;
+        }).join("-");
+        return `ws-preset-${preset.name}:${version}`;
+    }
+    async save(preset) {
+    }
+    async get(name) {
+        const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, name, "config.json");
+        return new makes_1.Preset({
+            name,
+            ...config
+        });
+    }
+    async search(options = {}) {
+        const { name } = options;
+        const presets = [];
+        const dirs = await makes_1.FS.readdir(env_1.PRESETS_DIR);
+        for (const dir of dirs) {
+            if (name && name !== dir) {
+                continue;
+            }
+            const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, dir, "config.json");
+            const preset = new makes_1.Preset({
+                name: dir,
+                ...config
+            });
+            presets.push(preset);
+        }
+        return presets;
+    }
+    async searchOne(options = {}) {
+        const [preset] = await this.search(options);
+        return preset || null;
+    }
+}
+exports.PresetService = PresetService;

package/lib/services/ProjectService.d.ts

@@ -1,13 +1,21 @@
-import { Project } from "src/models";
-import { AppConfigService } from "./AppConfigService";
-import { AppEventsService } from "./AppEventsService";
+import { DI, Project } from "../makes";
+import { DockerService, AppConfigService, AppEventsService } from "../services";
+type SearchParams = Partial<{
+    id: string;
+    name: string;
+    path: string;
+}>;
 declare class ProjectService {
     protected appConfigService: AppConfigService;
     protected appEventsService: AppEventsService;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService);
+    protected dockerService: DockerService;
+    constructor(di: DI);
     cdProject(name: string): Promise<void>;
     get(): Promise<Project>;
+    getContainer(): Promise<import("dockerode").Container>;
     start(): Promise<void>;
     stop(): Promise<void>;
+    save(project: Project): Promise<void>;
+    search(params?: Partial<SearchParams>): Promise<Project[]>;
 }
 export { ProjectService };