@twg-group/container-manager/dist/container/container.service.js

Container management for Docker, Swarm, Kubernetes

"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);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ContainerService = void 0;
const common_1 = require("@nestjs/common");
const strategies_1 = require("./strategies");
const nestjs_logger_1 = require("@twg-group/nestjs-logger");
const constants_1 = require("./constants");
let ContainerService = class ContainerService {
    strategy;
    logger;
    constructor(strategy, logger) {
        this.strategy = strategy;
        this.logger = logger;
    }
    async start(id) {
        try {
            await this.strategy.start(id);
        }
        catch (error) {
            this.logError(error, `Failed to start container ${id}`);
            throw error;
        }
    }
    async stop(id, timeout) {
        try {
            await this.strategy.stop(id, timeout);
        }
        catch (error) {
            this.logError(error, `Failed to stop container ${id}`);
            throw error;
        }
    }
    async deploy(config) {
        try {
            return await this.strategy.deploy(config);
        }
        catch (error) {
            this.logError(error, 'Deployment failed');
            throw error;
        }
    }
    async list(filter) {
        try {
            const containers = await this.strategy.list();
            if (!filter)
                return containers;
            return containers.filter((container) => {
                const basicMatch = (!filter.id || container.id.includes(filter.id)) &&
                    (!filter.name || container.name.includes(filter.name)) &&
                    (!filter.image || container.image.includes(filter.image)) &&
                    (!filter.status || container.status === filter.status) &&
                    (!filter.ports ||
                        filter.ports.every((p) => container.ports.includes(p))) &&
                    (!filter.createdFrom ||
                        new Date(container.createdAt) >= new Date(filter.createdFrom)) &&
                    (!filter.createdTo ||
                        new Date(container.createdAt) <= new Date(filter.createdTo));
                const labelsMatch = !filter.labels ||
                    filter.labels.every((filterLabel) => {
                        return Object.entries(filterLabel).every(([key, value]) => container.labels && container.labels[key] === value);
                    });
                const envMatch = !filter.env ||
                    filter.env.every((filterEnv) => {
                        return Object.entries(filterEnv).every(([key, value]) => container.env && container.env[key] === value);
                    });
                return basicMatch && labelsMatch && envMatch;
            });
        }
        catch (error) {
            this.logError(error, 'Failed to list containers');
            return [];
        }
    }
    async getById(id) {
        return (await this.strategy.list()).find((container) => container.id === id);
    }
    async logs(id, since, tail) {
        try {
            return await this.strategy.logs(id, since, tail);
        }
        catch (error) {
            this.logError(error, `Failed to get logs for ${id}`);
            return [];
        }
    }
    async remove(id) {
        try {
            await this.strategy.remove(id);
        }
        catch (error) {
            throw error;
        }
    }
    logError(error, context) {
        const message = error instanceof Error ? error.message : String(error);
        this.logger.error(`${context}: ${message}`, error instanceof Error ? error.stack : undefined);
    }
};
exports.ContainerService = ContainerService;
exports.ContainerService = ContainerService = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, common_1.Inject)(constants_1.CONTAINER_STRATEGY)),
    __metadata("design:paramtypes", [strategies_1.BaseStrategy,
        nestjs_logger_1.Logger])
], ContainerService);
//# sourceMappingURL=container.service.js.map