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

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const e = require("../../../../vendor/Package.internal.3.cjs");

const t = require("../../../lib/core/Provider.cjs");

const r = require("../../../decorators/di/Lifetime.cjs");

const i = require("../../../decorators/di/Configurable.cjs");

const n = require("../../../../vendor/Package.internal.7.cjs");

const o = require("../../../lib/helpers/IsAbortError.cjs");

const s = require("../../../lib/core/Time.cjs");

const a = require("../../../lib/helpers/As.cjs");

const c = require("../../../decorators/dto/Accept.cjs");

const p = require("../options/container/ContainerStopOptions.cjs");

const u = require("../options/container/ContainerRemoveOptions.cjs");

const l = require("../options/container/ContainerSettingOptions.cjs");

const d = require("../options/container/ContainerKillOptions.cjs");

const h = require("../../../lib/helpers/UniqueArray.cjs");

const m = require("./ParseEnvToRecord.cjs");

const g = require("../options/container/ContainerCommitOptions.cjs");

const y = require("./ParseRepositoryTag.cjs");

const C = require("../../../../vendor/Package.internal.56.cjs");

const q = require("../options/container/ContainerCreateTTYOptions.cjs");

const b = require("../options/container/ContainerLogsOptions.cjs");

const f = require("node:stream");

const _ = require("../options/container/ContainerExecOptions.cjs");

const j = require("../options/container/ContainerExportDirectoryOptions.cjs");

const w = require("stream/promises");

const P = require("node:fs");

require("../../../../vendor/Package.internal.4.cjs");

require("../../../lib/base/async-constructor/AsyncConstructor.cjs");

require("../../../lib/base/async-constructor/Append.cjs");

require("../../../lib/helpers/IsPromiseLike.cjs");

require("../../../lib/helpers/IsPromise.cjs");

require("util/types");

require("../../../exceptions/MethodNotFoundException.cjs");

require("../../../lib/base/abstracts/Exception.cjs");

require("../../../../vendor/Package.internal.5.cjs");

require("../../../../vendor/Package.internal.2.cjs");

require("../../../../vendor/Package.internal.6.cjs");

require("../../../lib/base/internal/ThrowWarning.cjs");

require("../../../lib/helpers/Templating.cjs");

require("../../../lib/base/internal/CamelCase.cjs");

require("../../../lib/helpers/NoCase.cjs");

require("../../../lib/helpers/DevNull.cjs");

require("../../../lib/ioc/DependencyInjectionContainer.cjs");

require("util");

require("../../../lib/ioc/Errors.cjs");

require("../../../exceptions/di/DependencyInjectionException.cjs");

require("../../../lib/base/internal/ConstructorSymbol.cjs");

require("../../../constants/DIMetadataKey.cjs");

require("../../../../vendor/Package.internal.1.cjs");

require("node:crypto");

require("../../../lib/base/internal/DataValidator.cjs");

require("node:util/types");

require("../../../lib/validation/VLD.cjs");

require("url");

require("../../../exceptions/dto/InvalidValueException.cjs");

require("../../../../vendor/Package.internal.8.cjs");

require("../../../lib/helpers/IsHtml.cjs");

require("../../../lib/helpers/IsXML.cjs");

require("../../../constants/DTOMetadataKey.cjs");

require("../../../lib/helpers/ObjectConstructor.cjs");

require("../../../lib/helpers/ObjectParentConstructors.cjs");

require("../../../lib/helpers/ObjectParentConstructor.cjs");

require("../../../lib/helpers/ObjectPrototype.cjs");

require("../../../lib/ioc/InjectionMode.cjs");

require("../../../lib/ioc/Lifetime.cjs");

require("../../../lib/ioc/ListModules.cjs");

require("os");

require("path");

require("stream");

require("events");

require("fs");

require("../../../lib/ioc/Utils.cjs");

require("../../../lib/ioc/FunctionTokenizer.cjs");

require("../../../lib/ioc/LoadModules.cjs");

require("../../../lib/ioc/Resolvers.cjs");

require("../../../lib/ioc/ParamParser.cjs");

require("../../../lib/base/internal/ObjectLifetime.cjs");

require("../../../exceptions/di/LifetimeLockedException.cjs");

require("../../../lib/base/internal/ObjectWeakRefs.cjs");

require("../../../lib/base/internal/ConfigurableRecordsInjection.cjs");

require("../../../lib/base/internal/ObjectConfiguration.cjs");

require("../../../lib/base/internal/ObjectInjection.cjs");

require("../../../lib/base/internal/ObjectContainer.cjs");

require("../../../decorators/dto/Expect.cjs");

require("../../../decorators/dto/IndexSignature.cjs");

require("../../../lib/helpers/IsEmptyObject.cjs");

require("../../../lib/base/internal/MethodValidation.cjs");

require("../../../exceptions/dto/InvalidMethodAcceptException.cjs");

require("../../../exceptions/dto/InvalidMethodReturnException.cjs");

require("../types/ContainerCapability.cjs");

require("querystring");

require("https");

require("http");

require("net");

require("child_process");

require("crypto");

require("assert");

require("buffer");

require("tls");

require("dns");

require("zlib");

require("../../../../vendor/Package.internal.52.cjs");

require("tty");

require("constants");

require("../../../../vendor/Package.internal.54.cjs");

require("../../../lib/core/Component.cjs");

require("../../../lib/base/EventEmitter.cjs");

require("node:os");

require("node:events");

require("node:diagnostics_channel");

require("worker_threads");

require("module");

require("node:path");

require("string_decoder");

require("node:worker_threads");

require("process");

require("http2");

require("../options/container/ContainerTTYConsoleSizeOptions.cjs");

require("../../../decorators/di/Inject.cjs");

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

e.__decorate([ i.Configurable(n.DTO.Function()), e.__metadata("design:type", Function) ], exports.DockerContainer.prototype, "getDockerode", void 0);

e.__decorate([ i.Configurable(n.DTO.Function()), e.__metadata("design:type", Function) ], exports.DockerContainer.prototype, "getDocker", void 0);

e.__decorate([ i.Configurable(n.DTO.String()), e.__metadata("design:type", String) ], exports.DockerContainer.prototype, "id", void 0);

e.__decorate([ c.Accept(p.ContainerStopOptions.optional()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ p.ContainerStopOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "stop", null);

e.__decorate([ c.Accept(p.ContainerStopOptions.optional()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ p.ContainerStopOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "restart", null);

e.__decorate([ c.Accept(u.ContainerRemoveOptions.optional()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ u.ContainerRemoveOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "remove", null);

e.__decorate([ c.Accept(l.ContainerSettingOptions.required()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ l.ContainerSettingOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "update", null);

e.__decorate([ c.Accept(g.ContainerCommitOptions.optional().default({})), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ g.ContainerCommitOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "commit", null);

e.__decorate([ c.Accept(q.ContainerCreateTTYOptions.optional()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ q.ContainerCreateTTYOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "createTTY", null);

e.__decorate([ c.Accept(b.ContainerLogsOptions.optional()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ b.ContainerLogsOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "logs", null);

e.__decorate([ c.Accept(_.ContainerExecOptions.required()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ _.ContainerExecOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "exec", null);

e.__decorate([ c.Accept(d.ContainerKillOptions.optional()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ d.ContainerKillOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "kill", null);

e.__decorate([ c.Accept(j.ContainerExportDirectoryOptions.required()), e.__metadata("design:type", Function), e.__metadata("design:paramtypes", [ j.ContainerExportDirectoryOptions ]), e.__metadata("design:returntype", Promise) ], exports.DockerContainer.prototype, "exportDirectory", null);

exports.DockerContainer = e.__decorate([ r.Transient() ], exports.DockerContainer);