lakutata/src/components/docker/lib/DockerContainer.mjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
import { _ as t, a as i } from "../../../../vendor/Package.internal.3.mjs";

import { Provider as e } from "../../../lib/core/Provider.mjs";

import { Transient as o } from "../../../decorators/di/Lifetime.mjs";

import { Configurable as r } from "../../../decorators/di/Configurable.mjs";

import { D as s } from "../../../../vendor/Package.internal.7.mjs";

import { IsAbortError as n } from "../../../lib/helpers/IsAbortError.mjs";

import { Time as a } from "../../../lib/core/Time.mjs";

import { As as p } from "../../../lib/helpers/As.mjs";

import { Accept as m } from "../../../decorators/dto/Accept.mjs";

import { ContainerStopOptions as c } from "../options/container/ContainerStopOptions.mjs";

import { ContainerRemoveOptions as l } from "../options/container/ContainerRemoveOptions.mjs";

import { ContainerSettingOptions as d } from "../options/container/ContainerSettingOptions.mjs";

import { ContainerKillOptions as h } from "../options/container/ContainerKillOptions.mjs";

import { UniqueArray as u } from "../../../lib/helpers/UniqueArray.mjs";

import { ParseEnvToRecord as g } from "./ParseEnvToRecord.mjs";

import { ContainerCommitOptions as f } from "../options/container/ContainerCommitOptions.mjs";

import { ParseRepositoryTag as y } from "./ParseRepositoryTag.mjs";

import { D as b } from "../../../../vendor/Package.internal.56.mjs";

import { ContainerCreateTTYOptions as j } from "../options/container/ContainerCreateTTYOptions.mjs";

import { ContainerLogsOptions as C } from "../options/container/ContainerLogsOptions.mjs";

import { Stream as w } from "node:stream";

import { ContainerExecOptions as P } from "../options/container/ContainerExecOptions.mjs";

import { ContainerExportDirectoryOptions as v } from "../options/container/ContainerExportDirectoryOptions.mjs";

import { pipeline as k } from "stream/promises";

import { createWriteStream as I } from "node:fs";

import "../../../../vendor/Package.internal.4.mjs";

import "../../../lib/base/async-constructor/AsyncConstructor.mjs";

import "../../../lib/base/async-constructor/Append.mjs";

import "../../../lib/helpers/IsPromiseLike.mjs";

import "../../../lib/helpers/IsPromise.mjs";

import "util/types";

import "../../../exceptions/MethodNotFoundException.mjs";

import "../../../lib/base/abstracts/Exception.mjs";

import "../../../../vendor/Package.internal.5.mjs";

import "../../../../vendor/Package.internal.2.mjs";

import "../../../../vendor/Package.internal.6.mjs";

import "../../../lib/base/internal/ThrowWarning.mjs";

import "../../../lib/helpers/Templating.mjs";

import "../../../lib/base/internal/CamelCase.mjs";

import "../../../lib/helpers/NoCase.mjs";

import "../../../lib/helpers/DevNull.mjs";

import "../../../lib/ioc/DependencyInjectionContainer.mjs";

import "util";

import "../../../lib/ioc/Errors.mjs";

import "../../../exceptions/di/DependencyInjectionException.mjs";

import "../../../lib/base/internal/ConstructorSymbol.mjs";

import "../../../constants/DIMetadataKey.mjs";

import "../../../../vendor/Package.internal.1.mjs";

import "node:crypto";

import "../../../lib/base/internal/DataValidator.mjs";

import "node:util/types";

import "../../../lib/validation/VLD.mjs";

import "url";

import "../../../exceptions/dto/InvalidValueException.mjs";

import "../../../../vendor/Package.internal.8.mjs";

import "../../../lib/helpers/IsHtml.mjs";

import "../../../lib/helpers/IsXML.mjs";

import "../../../constants/DTOMetadataKey.mjs";

import "../../../lib/helpers/ObjectConstructor.mjs";

import "../../../lib/helpers/ObjectParentConstructors.mjs";

import "../../../lib/helpers/ObjectParentConstructor.mjs";

import "../../../lib/helpers/ObjectPrototype.mjs";

import "../../../lib/ioc/InjectionMode.mjs";

import "../../../lib/ioc/Lifetime.mjs";

import "../../../lib/ioc/ListModules.mjs";

import "os";

import "path";

import "stream";

import "events";

import "fs";

import "../../../lib/ioc/Utils.mjs";

import "../../../lib/ioc/FunctionTokenizer.mjs";

import "../../../lib/ioc/LoadModules.mjs";

import "../../../lib/ioc/Resolvers.mjs";

import "../../../lib/ioc/ParamParser.mjs";

import "../../../lib/base/internal/ObjectLifetime.mjs";

import "../../../exceptions/di/LifetimeLockedException.mjs";

import "../../../lib/base/internal/ObjectWeakRefs.mjs";

import "../../../lib/base/internal/ConfigurableRecordsInjection.mjs";

import "../../../lib/base/internal/ObjectConfiguration.mjs";

import "../../../lib/base/internal/ObjectInjection.mjs";

import "../../../lib/base/internal/ObjectContainer.mjs";

import "../../../decorators/dto/Expect.mjs";

import "../../../decorators/dto/IndexSignature.mjs";

import "../../../lib/helpers/IsEmptyObject.mjs";

import "../../../lib/base/internal/MethodValidation.mjs";

import "../../../exceptions/dto/InvalidMethodAcceptException.mjs";

import "../../../exceptions/dto/InvalidMethodReturnException.mjs";

import "../types/ContainerCapability.mjs";

import "querystring";

import "https";

import "http";

import "net";

import "child_process";

import "crypto";

import "assert";

import "buffer";

import "tls";

import "dns";

import "zlib";

import "../../../../vendor/Package.internal.52.mjs";

import "tty";

import "constants";

import "../../../../vendor/Package.internal.54.mjs";

import "../../../lib/core/Component.mjs";

import "../../../lib/base/EventEmitter.mjs";

import "node:os";

import "node:events";

import "node:diagnostics_channel";

import "worker_threads";

import "module";

import "node:path";

import "string_decoder";

import "node:worker_threads";

import "process";

import "http2";

import "../options/container/ContainerTTYConsoleSizeOptions.mjs";

import "../../../decorators/di/Inject.mjs";

let S = class DockerContainer extends e {
    #t=new AbortController;
    get #i() {
        return this.getDockerode().getContainer(this.id);
    }
    async init() {
        await this.syncContainerInfo();
    }
    async destroy() {
        this.#t.abort();
    }
    async syncContainerInfo() {
        try {
            const t = await this.#i.inspect({
                abortSignal: this.#t.signal
            });
            this.createdAt = new a(t.Created);
            this.name = t.Name.substring(1);
            this.hostname = t.Config.Hostname;
            this.image = await this.getDocker().getImage(t.Image);
            this.restartCount = t.RestartCount;
            this.state = {
                status: p(t.State.Status),
                running: t.State.Running,
                paused: t.State.Paused,
                restarting: t.State.Restarting,
                OOMKilled: t.State.OOMKilled,
                dead: t.State.Dead,
                pid: t.State.Pid,
                exitCode: t.State.ExitCode,
                startedAt: t.State.StartedAt ? new a(t.State.StartedAt) : null,
                finishedAt: t.State.FinishedAt ? new a(t.State.FinishedAt) : null
            };
            const i = t.NetworkSettings ? t.NetworkSettings.Networks ? t.NetworkSettings.Networks : {} : {};
            this.tty = t.Config.Tty;
            this.OOMKillDisable = !!t.HostConfig.OomKillDisable;
            this.networks = Object.keys(i).map(t => ({
                networkName: t,
                networkId: i[t].NetworkID,
                endpointId: i[t].EndpointID,
                mac: i[t].MacAddress,
                ip: i[t].IPAddress,
                gateway: i[t].Gateway,
                ipPrefixLen: i[t].IPPrefixLen,
                ipv6: i[t].GlobalIPv6Address,
                ipv6Gateway: i[t].IPv6Gateway,
                ipv6PrefixLen: i[t].GlobalIPv6PrefixLen
            }));
            const e = [];
            this.networks.forEach(t => {
                if (t.ip) e.push(t.ip);
                if (t.ipv6) e.push(`[${t.ipv6}]`);
            });
            const o = [];
            const r = new Map;
            this.image.config.ports?.forEach(t => {
                e.forEach(i => {
                    const e = [];
                    if (t.tcp) e.push("tcp");
                    if (t.udp) e.push("udp");
                    e.forEach(e => {
                        const o = `${i}_${t.port}_${e}`;
                        if (!r.has(o)) r.set(o, []);
                    });
                });
            });
            if (t.NetworkSettings.Ports) {
                Object.keys(t.NetworkSettings.Ports).forEach(i => {
                    const o = i.split("/");
                    const s = parseInt(o[0]);
                    const n = p(o[1].toLowerCase());
                    t.NetworkSettings.Ports[i]?.forEach(t => {
                        e.forEach(i => {
                            const e = `${i}_${s}_${n}`;
                            if (!r.has(e)) r.set(e, []);
                            const o = r.get(e);
                            o.push(parseInt(t.HostPort));
                            r.set(e, o);
                        });
                    });
                });
            }
            r.forEach((t, i) => {
                const e = i.split("_");
                const r = e[0];
                const s = parseInt(e[1]);
                const n = p(e[2]);
                o.push({
                    host: r,
                    port: s,
                    type: n,
                    hostPorts: t
                });
            });
            this.ports = o;
            const s = [];
            t.Mounts.forEach(t => {
                if (t.Type === "bind") {
                    s.push({
                        hostPath: t.Source,
                        containerPath: t.Destination,
                        rw: t.RW
                    });
                }
            });
            this.binds = s;
            this.devices = t.HostConfig.Devices ? p(t.HostConfig.Devices).map(t => ({
                hostPath: t.PathOnHost,
                containerPath: t.PathInContainer,
                cgroupPermissions: t.CgroupPermissions
            })) : [];
            this.memoryLimit = t.HostConfig.Memory ? t.HostConfig.Memory : 0;
            this.privileged = !!t.HostConfig.Privileged;
            this.restartPolicy = t.HostConfig.RestartPolicy?.Name ? p(t.HostConfig.RestartPolicy.Name) : "";
            this.cgroup = t.HostConfig.Cgroup;
            this.cgroupParent = t.HostConfig.CgroupParent;
            this.pidMode = t.HostConfig.PidMode;
            const n = t.HostConfig.CpusetCpus ? t.HostConfig.CpusetCpus : "";
            const m = n.split(",");
            const c = m.map(t => {
                if (t.includes("-")) {
                    const [i, e] = t.split("-");
                    const o = [];
                    if (!i || !e) return o;
                    for (let t = parseInt(i); t <= parseInt(e); t++) o.push(t);
                    return o;
                } else {
                    return [ parseInt(t) ];
                }
            });
            let l = [];
            c.forEach(t => {
                l = [ ...t, ...l ];
            });
            this.cpuSet = u(l).sort((t, i) => t - i).filter(t => typeof t === "number" && !isNaN(t));
            this.env = g(t.Config.Env);
            this.capabilities = t.HostConfig.CapAdd ? t.HostConfig.CapAdd : [];
        } catch (t) {
            if (!n(t)) throw t;
        }
    }
    async start() {
        try {
            await this.#i.start({
                abortSignal: this.#t.signal
            });
            await this.syncContainerInfo();
        } catch (t) {
            if (!n(t)) throw t;
        }
    }
    async stop(t) {
        if (!t) return await this.stop({});
        try {
            const i = {
                abortSignal: this.#t.signal,
                signal: t.signal,
                t: t.timeout
            };
            await this.#i.stop(i);
            await this.syncContainerInfo();
        } catch (t) {
            if (!n(t)) throw t;
        }
    }
    async pause() {
        await this.#i.pause();
        await this.syncContainerInfo();
    }
    async unpause() {
        await this.#i.unpause();
        await this.syncContainerInfo();
    }
    async restart(t) {
        if (!t) return await this.restart({});
        try {
            const i = {
                abortSignal: this.#t.signal,
                signal: t.signal,
                t: t.timeout
            };
            await this.#i.restart(i);
            await this.syncContainerInfo();
        } catch (t) {
            if (!n(t)) throw t;
        }
    }
    async remove(t) {
        if (!t) return await this.remove({});
        const i = {
            force: !!t.force,
            v: true
        };
        await this.#i.remove(i);
    }
    async update(t) {
        const i = this.state.running;
        await this.remove({
            force: true
        });
        Object.keys(t).forEach(i => {
            if (t[i] === undefined) delete t[i];
        });
        const e = await this.getDocker().createContainer(this.image.id, this.image.platform, {
            name: this.name,
            hostname: this.hostname,
            privileged: this.privileged,
            env: this.env,
            tty: this.tty,
            memoryLimit: this.memoryLimit,
            cpuSet: this.cpuSet,
            restartPolicy: this.restartPolicy,
            ports: this.ports,
            binds: this.binds,
            devices: this.devices,
            networks: this.networks,
            OOMKillDisable: this.OOMKillDisable,
            capabilities: this.capabilities,
            cgroup: this.cgroup,
            cgroupParent: this.cgroupParent,
            pidMode: this.pidMode,
            ...t
        });
        this.id = e.id;
        if (i) {
            await this.start();
        } else {
            await this.syncContainerInfo();
        }
    }
    async commit(t) {
        if (!t) return await this.commit({});
        let i = undefined;
        let e = undefined;
        if (t.repoTag) {
            const o = y(t.repoTag);
            i = o.repo;
            e = o.tag;
        }
        const o = await this.#i.commit({
            repo: i,
            tag: e,
            pause: t.pauseBeforeCommitting !== undefined ? t.pauseBeforeCommitting : true
        });
        return await this.getDocker().getImage(o.Id);
    }
    async createTTY(t) {
        return await this.getObject(b, {
            container: this.#i,
            cmd: t?.cmd ? t.cmd : "bash",
            initialConsoleSize: t?.consoleSize
        });
    }
    async logs(t) {
        if (!t) return await this.logs({});
        if (t.follow) {
            return await this.#i.logs({
                follow: true,
                stdout: true,
                stderr: true,
                since: t.since,
                until: t.until,
                timestamps: t.timestamps,
                tail: t.tail
            });
        } else {
            const i = await this.#i.logs({
                follow: false,
                stdout: true,
                stderr: true,
                since: t.since,
                until: t.until,
                timestamps: t.timestamps,
                tail: t.tail
            });
            return w.Readable.from(i);
        }
    }
    async stats() {
        return await this.#i.stats({
            "one-shot": true,
            stream: false
        });
    }
    async exec(t) {
        const i = await this.#i.exec({
            Cmd: Array.isArray(t.cmd) ? t.cmd : [ t.cmd ],
            AttachStdout: true,
            AttachStderr: true
        });
        return new Promise((t, e) => {
            i.start({
                Detach: false
            }, (i, o) => {
                if (i) return e(i);
                let r = Buffer.from([]);
                if (!o) return t(r.toString());
                o.on("data", t => {
                    r = Buffer.from(new Uint8Array([ ...new Uint8Array(r), ...new Uint8Array(t) ]));
                }).once("close", () => t(r.toString())).once("error", t => e(t));
            });
        });
    }
    async kill(t) {
        if (!t) return await this.kill({});
        await this.#i.kill(t ? t : {});
        await this.syncContainerInfo();
    }
    async exportDirectory(t) {
        const i = await this.#i.getArchive({
            path: t.path
        });
        const e = typeof t.destination === "string" ? I(t.destination) : t.destination;
        await k(i, e);
    }
};

t([ r(s.Function()), i("design:type", Function) ], S.prototype, "getDockerode", void 0);

t([ r(s.Function()), i("design:type", Function) ], S.prototype, "getDocker", void 0);

t([ r(s.String()), i("design:type", String) ], S.prototype, "id", void 0);

t([ m(c.optional()), i("design:type", Function), i("design:paramtypes", [ c ]), i("design:returntype", Promise) ], S.prototype, "stop", null);

t([ m(c.optional()), i("design:type", Function), i("design:paramtypes", [ c ]), i("design:returntype", Promise) ], S.prototype, "restart", null);

t([ m(l.optional()), i("design:type", Function), i("design:paramtypes", [ l ]), i("design:returntype", Promise) ], S.prototype, "remove", null);

t([ m(d.required()), i("design:type", Function), i("design:paramtypes", [ d ]), i("design:returntype", Promise) ], S.prototype, "update", null);

t([ m(f.optional().default({})), i("design:type", Function), i("design:paramtypes", [ f ]), i("design:returntype", Promise) ], S.prototype, "commit", null);

t([ m(j.optional()), i("design:type", Function), i("design:paramtypes", [ j ]), i("design:returntype", Promise) ], S.prototype, "createTTY", null);

t([ m(C.optional()), i("design:type", Function), i("design:paramtypes", [ C ]), i("design:returntype", Promise) ], S.prototype, "logs", null);

t([ m(P.required()), i("design:type", Function), i("design:paramtypes", [ P ]), i("design:returntype", Promise) ], S.prototype, "exec", null);

t([ m(h.optional()), i("design:type", Function), i("design:paramtypes", [ h ]), i("design:returntype", Promise) ], S.prototype, "kill", null);

t([ m(v.required()), i("design:type", Function), i("design:paramtypes", [ v ]), i("design:returntype", Promise) ], S.prototype, "exportDirectory", null);

S = t([ o() ], S);

export { S as DockerContainer };