vdev/dist/realm.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.loadRealms = exports.assertRealm = exports.getRemoteImageName = exports.getConfigurationNames = exports.templatize = exports.formatAsTable = exports.renderRealmFile = exports.getCurrentRealm = exports.setRealm = void 0;
const backlib_1 = require("backlib");
const fs = __importStar(require("fs-extra"));
const Path = __importStar(require("path"));
const utils_min_1 = require("utils-min");
const docker_1 = require("./docker");
const hook_1 = require("./hook");
const k8s_1 = require("./k8s");
const renderer_1 = require("./renderer");
const utils_1 = require("./utils");
const vdev_config_1 = require("./vdev-config");
// --------- /Public Types --------- //
// --------- Public Realms APIs --------- //
/**
 * Set/Change the current (k8s context and eventual google project). Only change what is needed.
 * @param {*} realm the realm object.
 * @return {profileChanged?: true, contextChanged?: true} return a change object with what has changed.
 */
async function setRealm(realm) {
    const currentRealm = await getCurrentRealm(false);
    const change = {};
    // NOTE: When realm.project is undefined, it will set the gclougProject to undefined, 
    //       which is fine since we want to avoid accidental operation to the project.
    // FIXME: Needs to handle the case where realm.project is not defined (probably remove the current google project to make sure no side effect)
    const hookReturn = await hook_1.callHook(realm, 'realm_set_begin', currentRealm);
    if (hookReturn != null) {
        change.profileChanged = true;
    }
    if (realm.context === null) {
        console.log(`INFO: realm ${realm.name} does not have a kubernetes context, skipping 'kubectl config use-context ...' (current kubectl context still active)`);
    }
    else if (!currentRealm || currentRealm.context !== realm.context) {
        change.contextChanged = true;
        await k8s_1.setCurrentContext(realm.context);
    }
    return change;
}
exports.setRealm = setRealm;
/**
 * Get the current Realm. Return undefined if not found
 */
async function getCurrentRealm(check = true) {
    const realms = await loadRealms();
    const context = await k8s_1.getCurrentContext();
    let realm;
    for (let realmName in realms) {
        let realmItem = realms[realmName];
        if (realmItem.context === context) {
            realm = realmItem;
            break;
        }
    }
    if (check && realm) {
        await hook_1.callHook(realm, 'realm_check');
    }
    // if no context matching, try get the first realm that has no context
    if (!realm) {
        realm = Object.values(realms).find(r => r.context === null);
    }
    return realm;
}
exports.getCurrentRealm = getCurrentRealm;
/**
 * Render realm yaml file.
 * @param realm
 * @param name name of the yaml file (without extension)
 * @return The yaml file path
 */
async function renderRealmFile(realm, name) {
    const realmOutDir = getRealmOutDir(realm);
    const srcYamlFile = await findKFile(realm, name);
    const srcYamlFileName = Path.parse(srcYamlFile).base;
    const srcYamlContent = await fs.readFile(srcYamlFile, 'utf8');
    const outYamlFile = Path.join(realmOutDir, srcYamlFileName);
    // render the content
    var data = realm;
    const outYamlContent = await renderer_1.render(srcYamlContent, data);
    // for now, we do not generate do any template
    await fs.ensureDir(realmOutDir);
    await fs.writeFile(outYamlFile, outYamlContent);
    return outYamlFile;
}
exports.renderRealmFile = renderRealmFile;
function formatAsTable(realms, currentRealm) {
    const txts = [];
    const header = '  ' + 'REALM'.padEnd(20) + 'TYPE'.padEnd(12) + 'PROJECT/PROFILE'.padEnd(20) + 'CONTEXT';
    txts.push(header);
    const currentRealmName = (currentRealm) ? currentRealm.name : null;
    const currentProject = (currentRealm) ? currentRealm.project : null;
    for (let realm of Object.values(realms)) {
        let row = (realm.name === currentRealmName) ? "* " : "  ";
        row += realm.name.padEnd(20);
        row += realm.type.padEnd(12);
        let profile = (realm.type === 'gcp') ? realm.project : realm.profile;
        profile = (profile == null) ? '' : profile;
        row += profile.padEnd(20);
        row += (realm.context ? realm.context : 'NO CONTEXT FOUND');
        txts.push(row);
    }
    return txts.join('\n');
}
exports.formatAsTable = formatAsTable;
/**
 * Templatize a set of yaml files
 * @param resourceNames either a single name, comma deliminated set of names, or an array.
 */
async function templatize(realm, resourceNames) {
    const names = await getConfigurationNames(realm, resourceNames);
    const result = [];
    for (let name of names) {
        const path = await renderRealmFile(realm, name);
        result.push({ name, path });
    }
    return result;
}
exports.templatize = templatize;
// --------- /Resource Management --------- //
/**
 * Returns a list of k8s configuration file names for a given realm and optional configurations names delimited string or array.
 * - If configurationNames is an array, then, just return as is.
 * - If configurationNames is string (e.g., 'web-server, queue') then it will split on ',' and trim each item as returns.
 * - If no resourceNames then returns all of the resourceNames for the realm.
 */
async function getConfigurationNames(realm, configurationNames) {
    // Note: for now, we do the check if the realm has a context here, because this is called for each k*** commands
    // TODO: Might want to make it more explicit, as validateRealmForKubectlCommand(realm)
    if (realm.context === null) {
        throw Error(`Realm '${realm.name}' does not have a Kubernetes context, cannot perform kubectly commands.`);
    }
    if (configurationNames) {
        return utils_1.asNames(configurationNames);
    }
    else if (realm.defaultConfigurations) {
        return realm.defaultConfigurations;
    }
    else {
        return getAllConfigurationNames(realm);
    }
}
exports.getConfigurationNames = getConfigurationNames;
/**
 * Note: right now assume remote is on gke cloud (gcr.io/)
 * @param realm
 * @param serviceName
 */
function getRemoteImageName(block, realm) {
    return docker_1._getImageName(block, realm.registry);
}
exports.getRemoteImageName = getRemoteImageName;
function assertRealm(realm) {
    if (!realm) {
        throw new Error(`No realm found, do a 'npm run realm' to see the list of realm, and 'npm run realm realm_name' to set a realm`);
    }
    return realm;
}
exports.assertRealm = assertRealm;
// --------- Loader --------- //
async function loadRealms(rootDir) {
    var _a;
    const rawConfig = await vdev_config_1.loadVdevConfig(rootDir);
    const rawRealms = rawConfig.realms;
    const realms = {};
    const base = {
        system: rawConfig.system,
    };
    // get the _common variables and delete it from the realm list
    let _common = {};
    if (rawRealms._common) {
        _common = rawRealms._common;
        delete rawRealms._common;
    }
    // Create the realm object
    for (let name in rawRealms) {
        const rawRealm = rawRealms[name];
        // TODO: must do a deep merge
        const realm = { ...base, ..._common, ...rawRealm };
        // NOTE: this is needed in realm, because ktemplate does not know if the k8s yaml is related to which block
        // TODO: need to throw error if realm have a imageTag override
        realm.imageTag = rawConfig.imageTag;
        //// determine the type
        let type = 'local';
        const context = realm.context;
        if (context) {
            if (context.startsWith('arn:aws')) {
                type = 'aws';
                realm.profile = (realm.profile != null) ? realm.profile : 'default';
            }
            else if (context.startsWith('gke')) {
                type = 'gcp';
            }
            else if (realm.registry && realm.registry.includes('azurecr')) {
                type = 'azure';
            }
        }
        else {
            realm.context = null;
        }
        realm.type = type;
        //// determine registry
        if (!realm.registry) {
            if (type === 'local' && realm.context) { // do not create localhost registry for local realm without context
                realm.registry = 'localhost:5000/';
            }
            else if (type === 'gcp') {
                realm.registry = `gcr.io/${realm.project}/`;
            }
            else if (type === 'aws') {
                console.log(`WARNING - realm ${realm.name} of type 'aws' must have a registry property in the vdev.yaml`);
            }
        }
        // set the name
        realm.name = name;
        // set the yamlDirs from yamlDir
        realm.yamlDirs = (_a = realm.yamlDirs) !== null && _a !== void 0 ? _a : utils_min_1.asArray(realm.yamlDir);
        // Call hook to finish initializing the realm (i.e., realm type specific initialization)
        // TODO: not sure this is the right place to init the current realm. This is loading the realm. 
        await hook_1.callHook(realm, 'realm_init');
        realms[name] = realm;
    }
    return realms;
}
exports.loadRealms = loadRealms;
// --------- /Loader --------- //
// --------- Private Helpers --------- //
/** Get all of the resourceNames for a given realm */
async function getAllConfigurationNames(realm) {
    const nameSet = new Set();
    for (const yamlDir of realm.yamlDirs) {
        const yamlFiles = await backlib_1.glob('*.yaml', yamlDir);
        yamlFiles.forEach(file => { nameSet.add(Path.basename(file, '.yaml')); });
    }
    return Array.from(nameSet);
}
function getRealmOutDir(realm) {
    return Path.join(realm.yamlDirs[0], '.out/', realm.name + '/');
}
// get the Original Kubernets Yaml file (which could be a template)
async function findKFile(realm, kName) {
    const fileName = `${kName.trim()}.yaml`;
    for (const yamlDir of realm.yamlDirs) {
        const file = Path.join(yamlDir, fileName);
        if (await fs.pathExists(file)) {
            return file;
        }
    }
    throw new Error(`Kubernetes resource file ${fileName} not found in directories ${realm.yamlDirs.join(', ')}`);
}
async function cleanRealmOutDir(realm) {
    await backlib_1.saferRemove(getRealmOutDir(realm));
}
// --------- /Private Helpers --------- //