Cr 1077 - delete runner should delete runtime (#588)

Author: roi-codefresh

lib/interface/cli/commands/agent/delete.cmd.js

@@ -1,5 +1,6 @@
 const Command = require('../../Command');
 const CFError = require('cf-errors');
+const colors = require('colors');
 const { sdk } = require('../../../../logic');
 const deleteRoot = require('../root/delete.cmd');
 const { ignoreHttpError } = require('../../helpers/general');
@@ -32,7 +33,7 @@ const command = new Command({
         }
 
         await sdk.agents.delete({ agentId: agent.id });
-        console.log(`Agent '${name || id}' deleted.`);
+        console.log(`Agent "${colors.cyan(name || id)}" deleted.`);
     },
 });
 

lib/interface/cli/commands/hybrid/delete.cmd.js

@@ -10,15 +10,15 @@ const colors = require('colors');
 const DEFAULTS = require('../../defaults');
 const sdk = require('../../../../logic/sdk');
 const _ = require('lodash');
-const YAML = require('yaml');
-const fs = require('fs');
 const { to } = require('./../../../../logic/cli-config/errors/awaitTo');
 const {
     createErrorHandler,
     getRelatedAgents,
     getRelatedNamespaces,
     drawCodefreshFiglet,
     unInstallAppProxy,
+    mergeValuesFromValuesFile,
+    INSTALLATION_DEFAULTS,
 } = require('./helper');
 
 const defaultNamespace = 'codefresh';
@@ -29,14 +29,34 @@ async function promptConfirmationMessage({
     agentName,
     kubeNamespace,
     attachedRuntimes,
+    defaultRuntime,
+    clustersToDelete,
+    appProxyToDelete,
 }) {
+    const note = colors.underline(colors.yellow('Note'));
+    let newDefaultRuntime = defaultRuntime;
+
     // prompt confirmation message
     console.log(`${colors.red('This process will attempt to delete the following:')}`);
     console.log(`\u2022 Codefresh runner with the name "${colors.cyan(agentName)}"`);
-    attachedRuntimes.forEach((reName) => { console.log(`\u2022 Codefresh runtime with the name "${colors.cyan(reName)}"`); });
+    attachedRuntimes.forEach((reName) => { console.log(`\u2022 Codefresh runtime with the name "${colors.cyan(reName)}"${defaultRuntime === reName ? ' [default runtime]' : ''}`); });
     console.log('\u2022 Codefresh runner monitor component');
-    console.log('\u2022 Codefresh App-Proxy component (if exists)');
-    console.log(`* The kubernetes namespace "${colors.cyan(kubeNamespace)}" will ${colors.underline('not')} be deleted\n`);
+    clustersToDelete.forEach((cluster) => { console.log(`\u2022 Codefresh cluster integration: "${colors.cyan(cluster.selector)}"`); });
+    appProxyToDelete.forEach((appProxy) => { console.log(`\u2022 App-Proxy component: "${colors.cyan(appProxy)}"`); });
+
+    // if this includes your default runtime
+    if (attachedRuntimes.length > 0) {
+        if (defaultRuntime && attachedRuntimes.includes(defaultRuntime)) {
+            newDefaultRuntime = INSTALLATION_DEFAULTS.SAAS_RUNTIME;
+            console.log(`* ${note}: "${colors.cyan(defaultRuntime)}" is set as your default runtime-environment,`
+            + ` if you delete this runtime your new default runtime will be: "${colors.cyan(newDefaultRuntime)}"`);
+        }
+
+        console.log(`* ${note}: any pipeline set to run on one of the above runtime environments will be moved to`
+        + ` run on your ${newDefaultRuntime !== defaultRuntime ? 'new ' : ''}default runtime environment: "${colors.cyan(newDefaultRuntime)}"`);
+    }
+
+    console.log(`* ${note}: The kubernetes namespace "${colors.cyan(kubeNamespace)}" will ${colors.underline('not')} be deleted\n`);
 
     const answer = await inquirer.prompt({
         type: 'confirm',
@@ -50,6 +70,27 @@ async function promptConfirmationMessage({
     }
 }
 
+// returns the clusters that are referenced by the runtimesToDelete and not referenced by runtimesToKeep
+function getClustersToDelete(clusters, runtimes, runtimesToDelete) {
+    const potentialClustersNames = _(runtimesToDelete).map(re => _.get(re, 'runtimeScheduler.cluster.clusterProvider.selector')).compact().value();
+    const runtimesToDeleteNames = _(runtimesToDelete).map(re => _.get(re, 'metadata.name')).compact().value();
+
+    const potentialClustersToDelete = _.filter(clusters, c => potentialClustersNames.includes(c.selector));
+    const runtimesToKeep = _.filter(runtimes, re => !runtimesToDeleteNames.includes(_.get(re, 'metadata.name')));
+
+    return _.filter(potentialClustersToDelete, c => !_.find(runtimesToKeep, re => _.get(re, 'runtimeScheduler.cluster.clusterProvider.selector') === c.selector));
+}
+
+function getAppProxyToDelete(runtimesToDelete) {
+    return _.reduce(runtimesToDelete, (acc, re) => {
+        const appProxy = _.get(re, 'appProxy.externalIP');
+        if (appProxy) {
+            acc.push(appProxy);
+        }
+        return acc;
+    }, []);
+}
+
 const deleteCmd = new Command({
     root: false,
     parent: runnerRoot,
@@ -90,50 +131,39 @@ const deleteCmd = new Command({
             describe: 'Print logs',
         }),
     handler: async (argv) => {
+        let _argv = argv;
+
+        // read values from values file
+        if (argv.values) {
+            _argv = mergeValuesFromValuesFile(_argv, _argv.values, handleError);
+        }
+
         const {
             verbose,
-        } = argv;
-        let {
+            force,
             'kube-config-path': kubeConfigPath,
-            url, force,
+        } = _argv;
+        let {
+            url,
             'kube-context-name': kubeContextName,
             'kube-namespace': kubeNamespace,
             name: agentName,
-            values: valuesFile,
-        } = argv;
+        } = _argv;
 
         const [listReErr, runtimes] = await to(sdk.runtimeEnvs.list({ }));
         await handleError(listReErr, 'Failed to get runtime environments');
         const [listAgentsErr, agents] = await to(sdk.agents.list({ }));
         await handleError(listAgentsErr, 'Failed to get agents');
+        const [listClustersErr, clusters] = await to(sdk.clusters.list());
+        await handleError(listClustersErr, 'Failed to get cluster integrations');
 
-        if (!agents.length) {
+        if (!agents || !agents.length) {
             console.log('No runners found on your codefresh account');
             process.exit(0);
         }
 
         console.log(colors.green('This uninstaller will guide you through the runner uninstallation process'));
-        if (valuesFile) {
-            const valuesFileStr = fs.readFileSync(valuesFile, 'utf8');
-            valuesObj = YAML.parse(valuesFileStr);
-
-            if (!kubeConfigPath && valuesObj.ConfigPath) {
-                kubeConfigPath = valuesObj.ConfigPath;
-            }
-            if (!kubeNamespace && valuesObj.Namespace) {
-                kubeNamespace = valuesObj.Namespace;
-            }
-            if (!kubeContextName && valuesObj.Context) {
-                kubeContextName = valuesObj.Context;
-            }
-            if (!url && valuesObj.CodefreshHost) {
-                url = valuesObj.CodefreshHost;
-            }
 
-            if (!agentName && valuesObj.AgentId) {
-                agentName = valuesObj.AgentId;
-            }
-        }
         if (!url) {
             url = DEFAULTS.URL;
         }
@@ -216,9 +246,21 @@ const deleteCmd = new Command({
 `);
 
         const attachedRuntimes = agent.runtimes || [];
+        const runtimesToDelete = _.filter(runtimes, re => attachedRuntimes.includes(_.get(re, 'metadata.name')));
+        const defaultRuntime = _.get(_.find(runtimes, re => re.default), 'metadata.name');
+
+        const clustersToDelete = getClustersToDelete(clusters, runtimes, runtimesToDelete);
+        const appProxyToDelete = getAppProxyToDelete(runtimesToDelete);
 
         if (!force) {
-            await promptConfirmationMessage({ agentName, kubeNamespace, attachedRuntimes });
+            await promptConfirmationMessage({
+                agentName,
+                kubeNamespace,
+                attachedRuntimes,
+                defaultRuntime,
+                clustersToDelete,
+                appProxyToDelete,
+            });
         }
 
         await Promise.all(attachedRuntimes.map(async (reName) => {
@@ -233,16 +275,36 @@ const deleteCmd = new Command({
                 verbose,
             };
             const re = runtimes.find(runtime => runtime.metadata.name === reName);
+            if (!re) {
+                // re already deleted
+                return;
+            }
+
+            // remove runtime cluster components
+            console.log(`Deleting runtime-environment: ${colors.cyan(reName)} from cluster`);
+            const [uninstallReErr] = await to(unInstallRuntime.handler(uninstallRuntimeOptions));
+            handleError(uninstallReErr, `Failed to uninstall runtime-environment "${colors.cyan(reName)}"`);
+
+            // delete codefresh entity
+            console.log(`Deleting runtime-environment: "${colors.cyan(reName)}" from codefresh`);
+            await to(sdk.runtimeEnvs.delete({ name: reName, force: true })); // also delete default runtime
+
             if (re.appProxy) {
-                await unInstallAppProxy({
+                const [uninstallAppProxyErr] = await to(unInstallAppProxy({
                     kubeConfigPath,
                     kubeContextName,
                     kubeNamespace,
                     verbose,
-                });
+                }));
+                handleError(uninstallAppProxyErr, 'Failed to uninstall app-proxy');
+                console.log('App-Proxy uninstalled successfully');
             }
-            const [uninstallReErr] = await to(unInstallRuntime.handler(uninstallRuntimeOptions));
-            handleError(uninstallReErr, `Failed to uninstall runtime-environment "${colors.cyan(reName)}"`);
+        }));
+
+        await Promise.all(clustersToDelete.map(async (cluster) => {
+            console.log(`Deleting cluster integration: "${colors.cyan(cluster.selector)}"`);
+            const [clusterDeleteErr] = await to(sdk.clusters.delete({ id: cluster._id, provider: cluster.provider }));
+            handleError(clusterDeleteErr, 'Failed to delete cluster integration');
         }));
 
         const uninstallAgentOptions = {

lib/interface/cli/commands/hybrid/helper.js

@@ -18,6 +18,8 @@ const {
 } = require('./../../../../binary');
 const { pathExists } = require('../../helpers/general');
 const Promise = require('bluebird');
+const YAML = require('yaml');
+const fs = require('fs');
 
 const INSTALLATION_DEFAULTS = {
     NAMESPACE: 'codefresh',
@@ -31,6 +33,7 @@ const INSTALLATION_DEFAULTS = {
     RESUME_OLD_INSTALLATION: true,
     COMPONENTS_FOLDER: 'components',
     KUBECONFIG_PATH: path.join(homedir(), '.kube', 'config'),
+    SAAS_RUNTIME: 'SAAS runtime',
 };
 
 const RUNTIME_IMAGES = {
@@ -1006,6 +1009,71 @@ function getRuntimeImagesWithRegistryUrl(registry) {
     }, {});
 }
 
+function mergeValuesFromValuesFile(argv, valuesFile, handleError) {
+    const valuesFileStr = fs.readFileSync(valuesFile, 'utf8');
+    const valuesObj = YAML.parse(valuesFileStr);
+    const _argv = _.cloneDeep(argv);
+
+    _argv.yes = true; // don't ask any questions
+
+    if (!_.has(_argv, 'kube-config-path') && _.has(valuesObj, 'ConfigPath')) {
+        _.set(_argv, 'kube-config-path', valuesObj.ConfigPath);
+    }
+    if (!_.has(_argv, 'kube-context-name') && _.has(valuesObj, 'Context')) {
+        _.set(_argv, 'kube-context-name', valuesObj.Context);
+    }
+    if (!_.has(_argv, 'kube-namespace') && _.has(valuesObj, 'Namespace')) {
+        _.set(_argv, 'kube-namespace', valuesObj.Namespace);
+    }
+    if (!_.has(_argv, 'url') && _.has(valuesObj, 'CodefreshHost')) {
+        _.set(_argv, 'url', valuesObj.CodefreshHost);
+    }
+    if (!_.has(_argv, 'token') && _.has(valuesObj, 'Token')) {
+        _.set(_argv, 'token', valuesObj.Token);
+    }
+    if (!_.has(_argv, 'name') && _.has(valuesObj, 'AgentId')) {
+        _.set(_argv, 'name', valuesObj.AgentId);
+    }
+    if (!_.has(_argv, 'install-monitor') && _.has(valuesObj, 'Monitor.Enabled')) {
+        _.set(_argv, 'install-monitor', valuesObj.Monitor.Enabled);
+    }
+    if (_.get(valuesObj, 'AppProxy')) {
+        _.set(_argv, 'app-proxy', true);
+    }
+    if (!_.has(_argv, 'app-proxy-host') && _.get(valuesObj, 'AppProxy.Ingress.Host')) {
+        _.set(_argv, 'app-proxy-host', valuesObj.AppProxy.Ingress.Host);
+    }
+    if (_argv.appProxy && !_argv['app-proxy-host']) {
+        handleError(new Error('no hostname provided'), 'cannot install app-proxy component without a hostname', undefined, undefined, true);
+    }
+    if (!_.has(_argv, 'app-proxy-path-prefix') && _.get(valuesObj, 'AppProxy.Ingress.PathPrefix')) {
+        _.set(_argv, 'app-proxy-path-prefix', valuesObj.AppProxy.Ingress.PathPrefix);
+    }
+    if (!_.has(_argv, 'docker-daemon-access') && _.has(valuesObj, 'dockerDaemonScheduler.userAccess')) {
+        _.set(_argv, 'docker-daemon-access', valuesObj.dockerDaemonScheduler.userAccess);
+    }
+    if (_.get(_argv, 'envVars.length') === 0 && _.has(valuesObj, 'EnvVars')) {
+        _argv.envVars.push(...objectToKeyValueArray(_.get(valuesObj, 'EnvVars')));
+    }
+    if (!_.has(_argv, 'docker-registry') && _.has(valuesObj, 'DockerRegistry')) {
+        _.set(_argv, 'docker-registry', valuesObj.DockerRegistry);
+    }
+    if (!_.has(_argv, 'skip-cluster-test') && _.has(valuesObj, 'SkipClusterTest')) {
+        _.set(_argv, 'skip-cluster-test', valuesObj.SkipClusterTest);
+    }
+    if (_.has(valuesObj, 'RuntimeEnvironmentName')) {
+        _.set(_argv, 'runtimeName', valuesObj.RuntimeEnvironmentName);
+    }
+    if (_.has(valuesObj, 'Runtime.AdditionalEnvVars')) {
+        _.set(_argv, 'reEnvVars', valuesObj.Runtime.AdditionalEnvVars);
+    }
+    if (_.has(valuesObj, 'Runtime.resources')) {
+        _.set(_argv, 'reResources', valuesObj.Runtime.resources);
+    }
+
+    return _argv;
+}
+
 module.exports = {
     getRelatedAgents,
     createErrorHandler,
@@ -1042,6 +1110,7 @@ module.exports = {
     installAppProxy,
     unInstallAppProxy,
     upgradeAppProxy,
+    mergeValuesFromValuesFile,
     INSTALLATION_DEFAULTS,
     DefaultLogFormatter,
 };