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

An IoC-based universal application framework.

import { _ as t, a as e } from "../../../../vendor/Package.1.mjs";

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

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

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

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

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

import { ImageTagOptions as a } from "../options/image/ImageTagOptions.mjs";

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

import { ImageExportOptions as p } from "../options/image/ImageExportOptions.mjs";

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

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

import { DockerImageRepoTagNotFoundException as g } from "../exceptions/DockerImageRepoTagNotFoundException.mjs";

import { ImageRemoveOptions as d } from "../options/image/ImageRemoveOptions.mjs";

import { ImagePushOptions as j } from "../options/image/ImagePushOptions.mjs";

import { DockerImagePushException as b } from "../exceptions/DockerImagePushException.mjs";

import { createInterface as u } from "node:readline";

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

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

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

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

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

import "../../../../vendor/Package.3.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 "../../../lib/base/internal/BasicInfo.mjs";

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

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

import "../../../../vendor/Package.7.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/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.4.mjs";

import "node:crypto";

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

import "node:util/types";

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

import "../../../../vendor/Package.11.mjs";

import "url";

import "../../../../vendor/Package.10.mjs";

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

import "../../../../vendor/Package.9.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 "../../../../vendor/Package.8.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 "../../../lib/helpers/DevNull.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 "node:stream";

import "../options/auth/DockerAuthOptions.mjs";

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

let v = class DockerImage extends o {
    #t=new AbortController;
    get #e() {
        return this.getDockerode().getImage(this.id);
    }
    async init() {
        await this.syncImageInfo();
    }
    async destroy() {
        this.#t.abort();
    }
    async syncImageInfo() {
        const t = await this.#e.inspect();
        this.repoTags = t.RepoTags;
        this.createdAt = new n(t.Created);
        this.arch = t.Architecture;
        this.os = t.Os;
        this.platform = `${this.os}/${this.arch}`;
        this.size = t.Size;
        const e = [];
        const o = new Map;
        if (t.Config.ExposedPorts) {
            Object.keys(t.Config.ExposedPorts).forEach((t => {
                const e = t.split("/");
                const i = parseInt(e[0]);
                const r = y(e[1].toLowerCase());
                if (!o.has(i)) o.set(i, {
                    tcp: false,
                    udp: false
                });
                const s = o.get(i);
                s[r] = true;
                o.set(i, s);
            }));
            o.forEach(((t, o) => e.push({
                port: o,
                ...t
            })));
        }
        this.config = {
            hostname: t.Config.Hostname,
            user: t.Config.User,
            env: C(t.Config.Env),
            cmd: t.Config.Cmd,
            entrypoint: t.Config.Entrypoint ? Array.isArray(t.Config.Entrypoint) ? t.Config.Entrypoint : [ t.Config.Entrypoint ] : [],
            volumes: t.Config.Volumes ? Object.keys(t.Config.Volumes) : [],
            ports: e
        };
    }
    async tag(t) {
        try {
            await this.#e.tag({
                ...t,
                abortSignal: this.#t.signal
            });
            await this.syncImageInfo();
        } catch (t) {
            if (!h(t)) throw t;
        }
    }
    async export(t) {
        try {
            let e;
            if (t.repoTag) {
                if (!this.repoTags.includes(t.repoTag)) {
                    if (!t.createRepoTagIfNotExists) throw new g("The current image does not contain the RepoTag of {0}", [ t.repoTag ]);
                    const {repo: e, tag: o} = f(t.repoTag);
                    await this.tag({
                        repo: e,
                        tag: o
                    });
                }
                e = this.getDockerode().getImage(t.repoTag);
            } else {
                e = this.#e;
            }
            const o = await e.get();
            const i = typeof t.destination === "string" ? c(t.destination, {
                signal: this.#t.signal
            }) : t.destination;
            await l(o, i);
        } catch (t) {
            if (!h(t)) throw t;
        }
    }
    async push(t) {
        const e = t.tag ? t.tag : "latest";
        const o = `${t.repo}:${e}`;
        await this.tag({
            repo: t.repo,
            tag: e
        });
        await this.syncImageInfo();
        const i = await this.getDockerode().getImage(o).push({
            authconfig: t.auth ? {
                username: t.auth.username,
                password: t.auth.password,
                serveraddress: t.auth.serverAddress,
                email: t.auth.email
            } : undefined
        });
        return new Promise(((e, o) => {
            let r;
            u({
                input: i
            }).on("line", (e => {
                const o = JSON.parse(e);
                if (o.error) r = new b(o.error);
                if (t.outputCallback) t.outputCallback(o);
            })).once("close", (() => {
                if (r) return o(r);
                return e();
            }));
        }));
    }
    async remove(t) {
        try {
            await this.#e.remove({
                ...t,
                abortSignal: this.#t.signal
            });
        } catch (t) {
            if (!h(t)) throw t;
        }
    }
    async run(t) {
        const e = await this.getDocker().createContainer(this.id, this.platform, t);
        await e.start();
        return e;
    }
};

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

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

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

t([ m(a.required()), e("design:type", Function), e("design:paramtypes", [ a ]), e("design:returntype", Promise) ], v.prototype, "tag", null);

t([ m(p.required()), e("design:type", Function), e("design:paramtypes", [ p ]), e("design:returntype", Promise) ], v.prototype, "export", null);

t([ m(j.required()), e("design:type", Function), e("design:paramtypes", [ j ]), e("design:returntype", Promise) ], v.prototype, "push", null);

t([ m(d.optional().default({
    force: true
})), e("design:type", Function), e("design:paramtypes", [ d ]), e("design:returntype", Promise) ], v.prototype, "remove", null);

t([ m(I.required()), e("design:type", Function), e("design:paramtypes", [ I ]), e("design:returntype", Promise) ], v.prototype, "run", null);

v = t([ i() ], v);

export { v as DockerImage };