vdev/dist/realm.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("./utils");
const k8s_1 = require("./k8s");
const vdev_config_1 = require("./vdev-config");
const renderer_1 = require("./renderer");
const fs = require("fs-extra-plus");
const Path = require("path");
const hook_1 = require("./hook");
// --------- /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 = getKFile(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;
function getLocalImageName(realm, serviceName) {
    return _getImageName(realm, 'localhost:5000/', serviceName);
}
exports.getLocalImageName = getLocalImageName;
/**
 * Note: right now assume remote is on gke cloud (gcr.io/)
 * @param realm
 * @param serviceName
 */
function getRemoteImageName(realm, serviceName) {
    return _getImageName(realm, realm.registry, serviceName);
}
exports.getRemoteImageName = getRemoteImageName;
function _getImageName(realm, basePath, serviceName) {
    const tag = (realm.imageTag) ? realm.imageTag : 'latest';
    const repoName = getRepositoryName(realm, serviceName);
    return `${basePath}${repoName}:${tag}`;
}
function getRepositoryName(realm, serviceName) {
    return `${realm.system}-${serviceName}`;
}
exports.getRepositoryName = getRepositoryName;
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() {
    const rawConfig = await vdev_config_1.loadVdevConfig();
    const rawRealms = rawConfig.realms;
    const realms = {};
    const base = {
        system: rawConfig.system,
        k8sDir: rawConfig.k8sDir
    };
    // 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 = Object.assign(Object.assign(Object.assign({}, base), _common), rawRealm);
        //// 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;
        // Call hook to finiish initializing the realm (i.e., realm type specific initialization)
        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 dir = getRealmSrcDir(realm);
    const yamlFiles = await fs.glob('*.yaml', dir);
    // return the list of names only
    if (yamlFiles) {
        return yamlFiles.map((f) => { return Path.basename(f, '.yaml'); });
    }
    else {
        return []; // return empty list if nothing found
    }
}
function getRealmOutDir(realm) {
    return Path.join(realm.k8sDir, '~out/', realm.name + '/');
}
function getRealmSrcDir(realm) {
    return Path.join(realm.k8sDir, realm.yamlDir);
}
// get the Original Kubernets Yaml file (which could be a template)
function getKFile(realm, kName) {
    let k8sDir = getRealmSrcDir(realm);
    return Path.join(k8sDir, `${kName.trim()}.yaml`);
}
async function cleanRealmOutDir(realm) {
    await utils_1.saferRemove(getRealmOutDir(realm));
}
// --------- /Private Helpers --------- //