@hashgraph/solo/dist/src/core/dependency-managers/dependency-manager.js

An opinionated CLI tool to deploy and manage private Hedera Networks.

// SPDX-License-Identifier: Apache-2.0
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); }
};
import os from 'node:os';
import { SoloError } from '../errors/solo-error.js';
import { ShellRunner } from '../shell-runner.js';
import { HelmDependencyManager } from './helm-dependency-manager.js';
import { container, inject, injectable } from 'tsyringe-neo';
import * as constants from '../constants.js';
import { InjectTokens } from '../dependency-injection/inject-tokens.js';
import { KindDependencyManager } from './kind-dependency-manager.js';
import { KubectlDependencyManager } from './kubectl-dependency-manager.js';
import { PodmanDependencyManager } from './podman-dependency-manager.js';
import { VfkitDependencyManager } from './vfkit-dependency-manager.js';
import { GvproxyDependencyManager } from './gvproxy-dependency-manager.js';
import { CraneDependencyManager } from './crane-dependency-manager.js';
let DependencyManager = class DependencyManager extends ShellRunner {
    dependancyManagerMap;
    constructor(helmDepManager, kindDepManager, kubectlDependencyManager, podmanDependencyManager, vfkitDependencyManager, gvproxyDependencyManager, craneDependencyManager) {
        super();
        this.dependancyManagerMap = new Map();
        this.dependancyManagerMap.set(constants.HELM, helmDepManager || container.resolve(InjectTokens.HelmDependencyManager));
        this.dependancyManagerMap.set(constants.KIND, kindDepManager || container.resolve(InjectTokens.KindDependencyManager));
        this.dependancyManagerMap.set(constants.KUBECTL, kubectlDependencyManager || container.resolve(InjectTokens.KubectlDependencyManager));
        this.dependancyManagerMap.set(constants.PODMAN, podmanDependencyManager || container.resolve(InjectTokens.PodmanDependencyManager));
        this.dependancyManagerMap.set(constants.VFKIT, vfkitDependencyManager || container.resolve(InjectTokens.VfkitDependencyManager));
        this.dependancyManagerMap.set(constants.GVPROXY, gvproxyDependencyManager || container.resolve(InjectTokens.GvproxyDependencyManager));
        this.dependancyManagerMap.set(constants.CRANE, craneDependencyManager || container.resolve(InjectTokens.CraneDependencyManager));
    }
    async getDependency(dependency) {
        const manager = this.dependancyManagerMap.get(dependency);
        if (manager) {
            return manager;
        }
        throw new SoloError(`Dependency manager for '${dependency}' is not found`);
    }
    /**
     * Check if the required dependency is installed or not
     * @param dependency - is the name of the program
     */
    async checkDependency(dependency) {
        this.logger.debug(`Checking for dependency: ${dependency}`);
        let status = false;
        const manager = this.dependancyManagerMap.get(dependency);
        if (manager) {
            status = await manager.install();
        }
        if (!status) {
            throw new SoloError(`Dependency '${dependency}' is not found`);
        }
        this.logger.debug(`Dependency '${dependency}' is found`);
        return true;
    }
    async skipDependency(dependency) {
        let skip = false;
        const manager = this.dependancyManagerMap.get(dependency);
        if (manager) {
            skip = !(await manager.shouldInstall());
        }
        this.logger.debug(`Skipping install of for dependency: ${dependency}: ${skip}`);
        return skip;
    }
    taskCheckDependencies(dependencies) {
        return dependencies.map((dependency) => {
            return {
                title: `Check dependency: ${dependency} [OS: ${os.platform()}, Release: ${os.release()}, Arch: ${os.arch()}]`,
                task: () => this.checkDependency(dependency),
                skip: () => this.skipDependency(dependency),
            };
        });
    }
    async getExecutable(dependency) {
        const manager = this.dependancyManagerMap.get(dependency);
        if (manager) {
            return await manager.getExecutable();
        }
        throw new SoloError(`Dependency manager for '${dependency}' is not found`);
    }
};
DependencyManager = __decorate([
    injectable(),
    __param(0, inject(InjectTokens.HelmDependencyManager)),
    __param(1, inject(InjectTokens.KindDependencyManager)),
    __param(2, inject(InjectTokens.KubectlDependencyManager)),
    __param(3, inject(InjectTokens.PodmanDependencyManager)),
    __param(4, inject(InjectTokens.VfkitDependencyManager)),
    __param(5, inject(InjectTokens.GvproxyDependencyManager)),
    __param(6, inject(InjectTokens.CraneDependencyManager)),
    __metadata("design:paramtypes", [HelmDependencyManager,
        KindDependencyManager,
        KubectlDependencyManager,
        PodmanDependencyManager,
        VfkitDependencyManager,
        GvproxyDependencyManager,
        CraneDependencyManager])
], DependencyManager);
export { DependencyManager };
//# sourceMappingURL=dependency-manager.js.map