vdev/dist/k8s.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.setCurrentContext = exports.getCurrentContext = exports.kexec = exports.kshRestart = exports.klogs = exports.kdel = exports.kapply = exports.kcreate = void 0;
const p_spawn_1 = require("p-spawn");
const k8s_types_1 = require("./k8s-types");
const realm_1 = require("./realm");
const utils_1 = require("./utils");
// --------- Public create/delete/logs/restart --------- //
async function kcreate(realm, resourceNames) {
    await kubectlFile(realm, 'create', resourceNames);
}
exports.kcreate = kcreate;
async function kapply(realm, resourceNames) {
    await kubectlFile(realm, 'apply', resourceNames);
}
exports.kapply = kapply;
// TODO: need to have a way to force the YES when use as API outside of cmd.
async function kdel(realm, resourceNames) {
    if (realm.confirmOnDelete) {
        const answer = await utils_1.prompt("Do you really want to delete? (YES to continue)");
        if (answer !== "YES") {
            console.log(`Operation not confirmed. Exiting (nothing done).`);
            return;
        }
    }
    await kubectlFile(realm, 'delete', resourceNames);
}
exports.kdel = kdel;
let currentLogPodName = null;
async function klogs(realm, resourceNames) {
    const names = await realm_1.getConfigurationNames(realm, resourceNames);
    const pods = await fetchK8sObjectsByType(realm, 'pods');
    for (let serviceName of names) {
        const kpods = await getKPods(pods, { labels: { run: `${realm.system}-${serviceName}` } });
        for (const kpod of kpods) {
            const podName = kpod.name;
            for (const ctn of kpod.containers) {
                const ctnName = ctn.name;
                const args = ['logs', '-f', podName, '-c', ctnName];
                addNamespaceIfDefined(realm, args);
                console.log(`Will output logs for -> kubectl ${args.join(' ')}`);
                // Note: here we do not await, because, we want to be able to launch multiple at the same time, and not be blocking.
                p_spawn_1.spawn('kubectl', args, {
                    detached: true,
                    onStdout: function (data) {
                        // If we had a log block before, and not the same as this one, we end it. 
                        if (currentLogPodName != null && currentLogPodName !== podName) {
                            console.log('-----------\n');
                        }
                        // if the current log block is not this one, we put a new start
                        if (currentLogPodName !== podName) {
                            console.log(`----- LOG for: ${serviceName} / ${podName} / ${ctnName}`);
                            currentLogPodName = podName;
                        }
                        // print the info
                        process.stdout.write(data);
                    }
                });
            }
        }
    }
}
exports.klogs = klogs;
/**
 * Will kubectl exec /service/restart.sh (will assume the pods/containers has one).
 * Assumptions:
 *   - One container per pod.
 *   - Does not check if /service/restart.sh exists, so, will crash if not.
 * @param runLabelPrefix
 * @param serviceNamesStr
 */
async function kshRestart(realm, serviceNamesStr) {
    const serviceNames = utils_1.asNames(serviceNamesStr);
    const pods = await fetchK8sObjectsByType(realm, 'pods');
    for (let serviceName of serviceNames) {
        const podNames = await getPodNames(pods, { labels: { run: `${realm.system}-${serviceName}` } });
        for (let podName of podNames) {
            // TODO need to check if there is a /service/restart.sh
            try {
                const args = ['exec', podName];
                addNamespaceIfDefined(realm, args);
                args.push('--', 'test', '-e', '/service/restart.sh');
                await p_spawn_1.spawn('kubectl', args, { toConsole: false });
            }
            catch (ex) {
                console.log(`Skipping service ${serviceName} - '/service/restart.sh' not found.`);
                continue;
            }
            console.log(`\n--- Restarting: ${serviceName} (pod: ${podName})`);
            const args = ['exec', podName];
            addNamespaceIfDefined(realm, args);
            args.push('--', '/service/restart.sh');
            await p_spawn_1.spawn('kubectl', args);
            console.log(`--- DONE: ${serviceName} : ${podName}`);
        }
    }
    // TODO: Run: kubectl exec $(kubectl get pods -l run=halo-web-server --no-headers=true -o custom-columns=:metadata.name) -- /service/restart.sh
    // TODO: needs to check if the service has restart.sh in the source tree, otherwise warn and skip the service
}
exports.kshRestart = kshRestart;
async function kexec(realm, serviceNamesStr, commandAndArgs) {
    const serviceNames = utils_1.asNames(serviceNamesStr);
    const pods = await fetchK8sObjectsByType(realm, 'pods');
    for (let serviceName of serviceNames) {
        const podNames = await getPodNames(pods, { labels: { run: `${realm.system}-${serviceName}` } });
        for (let podName of podNames) {
            try {
                let args = ['exec', podName];
                addNamespaceIfDefined(realm, args);
                args.push('--'); // base arguments
                args = args.concat(commandAndArgs); // we add the sub command and arguments
                await p_spawn_1.spawn('kubectl', args); // for now, we have it in the toConsole, but should put it configurable
            }
            catch (ex) {
                console.log(`Cannot run ${commandAndArgs} on pod ${podName} because ${ex}`);
                continue;
            }
        }
    }
}
exports.kexec = kexec;
// --------- /Public create/delete/logs/restart --------- //
// --------- Public get/set context --------- //
// fetch the current context
async function getCurrentContext() {
    // kubectl config current-context
    const psResult = await p_spawn_1.spawn('kubectl', ['config', 'current-context'], { capture: ['stdout', 'stderr'], ignoreFail: true });
    if (psResult.stderr) {
        // console.log(`INFO: ${psResult.stderr}`);
        return null;
    }
    else {
        return psResult.stdout.toString().trim();
    }
}
exports.getCurrentContext = getCurrentContext;
async function setCurrentContext(name) {
    // TODO: perhaps when null, should unset it: 'kubectl config unset current-context'
    //       downside is that it can create some unwanted side effect, if the user has another context set
    await p_spawn_1.spawn('kubectl', ['config', 'use-context', name]);
}
exports.setCurrentContext = setCurrentContext;
async function kubectlFile(realm, action, resourceNames) {
    const names = await realm_1.getConfigurationNames(realm, resourceNames);
    for (let name of names) {
        const fileName = await realm_1.renderRealmFile(realm, name);
        try {
            const args = [action, '-f', fileName];
            addNamespaceIfDefined(realm, args);
            await p_spawn_1.spawn('kubectl', args);
        }
        catch (ex) {
            console.log(`Can't k${action} ${fileName}, skipping`);
        }
        console.log();
    }
}
function addNamespaceIfDefined(realm, args) {
    const namespace = realm.namespace;
    if (namespace) {
        args.push('--namespace', namespace);
    }
}
// Fetch the pod for a part
async function fetchK8sObjectsByType(realm, type) {
    const args = ['get', type, '-o', 'json'];
    addNamespaceIfDefined(realm, args);
    const psResult = await p_spawn_1.spawn('kubectl', args, { capture: 'stdout' });
    const podsJsonStr = psResult.stdout.toString();
    const response = JSON.parse(podsJsonStr);
    return response.items || [];
}
// return the pod names 
function getPodNames(pods, filter) {
    const kpods = getKPods(pods, filter);
    return kpods.map(kpod => kpod.name);
}
/**
 * Return the list of kpods for a give list of PodItems and a optional filter.
 * @param pods PodItem array
 * @param filter PodItemFilter
 */
function getKPods(pods, filter) {
    const kpods = [];
    for (let item of pods) {
        let pass = true;
        const itemName = item.metadata.name;
        // test the filter.imageName
        if (filter && filter.imageName) {
            // Note: for now, just assume one container per pod, which should be the way to go anyway.
            const itemImageName = (item.spec && item.spec.containers) ? item.spec.containers[0].image : null;
            if (itemImageName != null && itemImageName.startsWith(filter.imageName)) {
                pass = true;
            }
            else {
                // pass = false;
                continue; // if false, we can stop this item now.
            }
        }
        // test the filter.labels
        if (filter && filter.labels) {
            for (let labelName in filter.labels) {
                if (item.metadata.labels[labelName] === filter.labels[labelName]) {
                    pass = true;
                }
                else {
                    pass = false;
                    continue; // if false, we can stop now
                }
            }
        }
        // 
        if (pass) {
            kpods.push(k8s_types_1.toKPod(item));
        }
    }
    return kpods;
}
// --------- /Private Utils --------- //