codefresh 0.78.2

package/lib/interface/cli/commands/runtimeEnvironments/attach.cmd.js

@@ -0,0 +1,161 @@
+/* eslint-disable max-len */
+const _ = require('lodash');
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const ProgressEvents = require('../../helpers/progressEvents');
+const cliProgress = require('cli-progress');
+const { getKubeContext } = require('../../helpers/kubernetes');
+const { DefaultLogFormatter } = require('./../hybrid/helper');
+
+const attachAgentToRuntime = async (agent, name) => {
+    const rt = await sdk.runtimeEnvs.get({ name });
+    if (!rt) {
+        throw new Error(`runtime ${name} does not exist on the account`);
+    }
+    if (!rt.metadata.agent) {
+        throw new Error('cannot attach non hybrid runtime');
+    }
+    const runtimes = _.get(agent, 'runtimes', []);
+    const existingRT = _.find(runtimes, value => value === name);
+    if (!existingRT) {
+        runtimes.push(name);
+        await sdk.agents.update({ agentId: agent.id, runtimes });
+    } else {
+        throw new Error(`Runtime ${name} already attached`);
+    }
+};
+
+const attachRuntimeCmd = new Command({
+    root: true,
+    command: 'attach runtime',
+    description: 'Attach a runtime to agent',
+    usage: 'attach runtime',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Attach Runtime-Environments',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('runtime-name', {
+            describe: 'Runtime\'s name',
+        })
+        .option('agent-name', {
+            describe: 'Agent\'s name',
+        })
+        .option('agent-id', {
+            describe: 'Agent\'s ID',
+        })
+        .option('runtime-kube-context-name', {
+            describe: 'Runtime kubernetes context',
+        })
+        .option('runtime-kube-namespace', {
+            describe: 'Runtime\'s namespace',
+        })
+        .option('runtime-kube-config-path', {
+            describe: 'Path to kubeconfig file for runtime (default is $HOME/.kube/config)',
+        })
+        .option('agent-kube-context-name', {
+            describe: 'Agent kubernetes context',
+        })
+        .option('agent-kube-namespace', {
+            describe: 'Agent\'s namespace',
+        })
+        .option('agent-kube-config-path', {
+            describe: 'Path to kubeconfig file for the agent (default is $HOME/.kube/config)',
+        })
+        .option('restart-agent', {
+            describe: 'restart agent afte install - default false',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        const {
+            'agent-name': agentName,
+            'runtime-name': runtimeName,
+            'agent-id': agentId,
+            'runtime-kube-namespace': kubeNamespace,
+            'runtime-kube-config-path': kubeConfigPath,
+            'agent-kube-namespace': agentKubeNamespace,
+            'agent-kube-config-path': agentKubeConfigPath,
+            'runtime-kube-serviceaccount': kubeServiceAccount,
+            'restart-agent': restartAgent,
+            verbose,
+
+        } = argv;
+        let {
+            'runtime-kube-context-name': kubeContextName,
+            'agent-kube-context-name': agentKubeContextName,
+        } = argv;
+        const { terminateProcess } = argv;
+        let agent;
+        if (_.isNull(runtimeName) || _.isUndefined(runtimeName) || runtimeName === '') {
+            throw new Error('runtime name is mandatory');
+        }
+        if (agentName) {
+            agent = await sdk.agents.getByName({ name: agentName });
+        } else if (agentId) {
+            agent = await sdk.agents.get({ agentId });
+        } else {
+            throw new Error('agent name or agent id is needed');
+        }
+        if (agent === '' || !agent) {
+            throw new Error('agent was not found');
+        }
+        if (!kubeNamespace) {
+            throw new Error('runtime-kube-namespace is mandatory parameter');
+        }
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+        if (!agentKubeContextName) {
+            agentKubeContextName = kubeContextName;
+        }
+
+        await attachAgentToRuntime(agent, runtimeName);
+
+        // call venonactl to attach
+
+        const events = new ProgressEvents();
+        const format = 'downloading [{bar}] {percentage}% | {value}/{total}';
+        const progressBar = new cliProgress.SingleBar({ stopOnComplete: true, format }, cliProgress.Presets.shades_classic);
+        let totalSize;
+        events.onStart((size) => {
+            progressBar.start(size, 0);
+            totalSize = size;
+        });
+        events.onProgress((progress) => {
+            progressBar.update(progress);
+            if (progress >= totalSize) {
+                console.log('\n');
+            }
+        });
+        await sdk.runtime.attach({
+            kubeContextName,
+            kubeServiceAccount,
+            kubeNamespace,
+            kubeConfigPath,
+            agentKubeContextName,
+            agentKubeNamespace,
+            agentKubeConfigPath,
+            runtimeName,
+            verbose,
+            restartAgent,
+            terminateProcess: false,
+            events,
+            logFormatting: DefaultLogFormatter,
+        });
+        if (!restartAgent) {
+            console.log('Please restart agent\'s pod in order that changes will take effect');
+        }
+        if (terminateProcess || terminateProcess === undefined) {
+            process.exit();
+        } else {
+            return 0;
+        }
+    },
+});
+
+
+module.exports = attachRuntimeCmd;

package/lib/interface/cli/commands/runtimeEnvironments/create.cmd.js

@@ -0,0 +1,23 @@
+const Command = require('../../Command');
+const createRoot = require('../root/create.cmd');
+
+const DEPRECATION_MESSAGE = 'Create runtime-environment command has been deprecated.\nUse codefresh install runtime command instead';
+
+const command = new Command({
+    command: 'runtime-environments [cluster]',
+    aliases: ['re', 'runtime-environment'],
+    parent: createRoot,
+    description: 'Create a runtime environment',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Create Runtime-Environments',
+        weight: 100,
+    },
+    handler: async () => {
+        console.log(`${DEPRECATION_MESSAGE}`);
+        process.exit(1);
+    },
+});
+
+
+module.exports = command;

package/lib/interface/cli/commands/runtimeEnvironments/delete.cmd.js

@@ -0,0 +1,35 @@
+const debug = require('debug')('codefresh:cli:create:pipelines2');
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const deleteRoot = require('../root/delete.cmd');
+
+
+const command = new Command({
+    command: 'runtime-environments name',
+    aliases: ['re', 'runtime-environment'],
+    parent: deleteRoot,
+    description: 'Delete a runtime-environment',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Delete Runtime-Environments',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Runtime environment name',
+            })
+            .option('force', {
+                describe: 'Delete runtime environment in force mode',
+                type: 'boolean',
+            });
+    },
+    handler: async (argv) => {
+        const { name, force } = argv;
+        await sdk.runtimeEnvs.delete({ name, force });
+        console.log(`Runtime-Environment '${name}' deleted.`);
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/runtimeEnvironments/diff.cmd.js

@@ -0,0 +1,64 @@
+const Command = require('../../Command');
+const jsdiff = require('diff');
+require('colors');
+const { sdk } = require('../../../../logic');
+
+const diffRoot = require('../root/diff.cmd');
+
+
+const command = new Command({
+    command: 'runtime-environments [first-re-name] [first-re-version] [second-re-name] [second-re-version]',
+    aliases: ['re', 'runtime-environment'],
+    parent: diffRoot,
+    description: 'Show diff between two runtime environments configuration',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Diff Runtime-Environments',
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('first-name', {
+                describe: 'First runtime environment name',
+            })
+            .option('first-version', {
+                describe: 'First runtime environment version',
+            })
+            .option('second-name', {
+                describe: 'Second runtime environment name',
+            })
+            .option('second-version', {
+                describe: 'Second runtime environment version',
+            });
+    },
+    handler: async (argv) => {
+        const firstEnvName = argv['first-name'];
+        const firstEnvVersion = argv['first-version'];
+        const secondEnvName = argv['second-name'];
+        const secondEnvVersion = argv['second-version'];
+
+        const firstEnv = await sdk.runtimeEnvs.get({
+            name: firstEnvName,
+            version: firstEnvVersion,
+        });
+
+        const secondtEnv = await sdk.runtimeEnvs.get({
+            name: secondEnvName,
+            version: secondEnvVersion,
+        });
+
+        const firstEnvJson = JSON.stringify(firstEnv, null, '\t');
+        const secondEnvJson = JSON.stringify(secondtEnv, null, '\t');
+
+        const diff = jsdiff.diffJson(firstEnvJson, secondEnvJson);
+
+        diff.forEach((part) => {
+            const color = part.added ? 'green' : part.removed ? 'red' : 'white';
+            process.stderr.write(part.value[color]);
+        });
+
+        console.log();
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/runtimeEnvironments/get.cmd.js

@@ -0,0 +1,76 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const RuntimeEnvironments = require('../../../../logic/entities/RuntimeEnvironments');
+const Output = require('../../../../output/Output');
+const DEFAULTS = require('../../defaults');
+const CFError = require('cf-errors'); // eslint-disable-line
+const getRoot = require('../root/get.cmd');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'runtime-environments [name]',
+    aliases: ['re', 'runtime-environment'],
+    parent: getRoot,
+    description: 'Get a runtime environments configuration',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Get Runtime-Environments',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Runtime environments name',
+            })
+            .option('version', {
+                describe: 'Runtime environments version',
+            })
+            .option('history', {
+                describe: 'Return all the history of the specific runtime environments',
+                type: 'boolean',
+            })
+            .option('limit', {
+                describe: 'Limit amount of returned results',
+                default: DEFAULTS.GET_LIMIT_RESULTS,
+            })
+            .option('page', {
+                describe: 'Paginated page',
+                default: DEFAULTS.GET_PAGINATED_PAGE,
+            })
+            .option('extend', {
+                describe: 'Return an extend runtime environment ',
+                type: 'boolean',
+                default: false,
+            });
+    },
+    handler: async (argv) => {
+        const { name, version, history, extend, limit, page } = argv;
+        const offset = (page - 1) * limit;
+        if (history) {
+            if (!name) {
+                throw new CFError('Name must be provided for history');
+            }
+            const allHistory = await sdk.runtimeEnvs.get({
+                name,
+                history,
+            });
+            console.log(JSON.stringify(allHistory, null, '\t'));
+        } else if (name) {
+            const currRuntimeEnvironments = await sdk.runtimeEnvs.get({
+                name,
+                version,
+                extend,
+            });
+            Output.print(RuntimeEnvironments.fromResponse(currRuntimeEnvironments));
+        } else {
+            const re = await sdk.runtimeEnvs.list({
+                limit,
+                offset,
+            });
+            Output.print(_.map(re, RuntimeEnvironments.fromResponse));
+        }
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/runtimeEnvironments/install.cmd.js

@@ -0,0 +1,312 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+const attachRuntimeCmd = require('./attach.cmd');
+const installRoot = require('../root/install.cmd');
+const { getKubeContext } = require('../../helpers/kubernetes');
+const ProgressEvents = require('../../helpers/progressEvents');
+const cliProgress = require('cli-progress');
+const createClusterCmd = require('../cluster/create.cmd');
+const colors = require('colors');
+const _ = require('lodash');
+const { DefaultLogFormatter, INSTALLATION_DEFAULTS } = require('./../hybrid/helper');
+
+const defaultNamespace = 'codefresh';
+const defaultStorageClassPrefix = 'dind-local-volumes-runner';
+const maxRuntimeNameLength = 63;
+
+async function newRuntimeName(kubeContextName, kubeNamespace) {
+    const defaultName = `${kubeContextName}/${kubeNamespace}`.slice(0, maxRuntimeNameLength);
+    const runtimes = await sdk.runtimeEnvs.list({ });
+    let name;
+
+    if (!_.isArray(runtimes) || !_.find(runtimes, re => _.get(re, 'metadata.name') === defaultName)) {
+        name = defaultName; // use the default name if there are no collisions
+    } else {
+        const reNames = new Set(_.map(runtimes, re => _.get(re, 'metadata.name'))); // for fast lookup
+        let i = 1;
+        let suggestName;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            suggestName = `${defaultName.slice(0, maxRuntimeNameLength - 1 - i.toString().length)}_${i}`;
+            if (!reNames.has(suggestName)) {
+                break;
+            }
+            i += 1;
+        }
+        name = suggestName;
+    }
+
+    return name;
+}
+const installRuntimeCmd = new Command({
+    root: false,
+    parent: installRoot,
+    command: 'runtime',
+    description: 'Install and create a runtime on kubernetes cluster',
+    webDocs: {
+        category: 'Runtime-Environments',
+        title: 'Install Runtime-Environment',
+        weight: 100,
+    },
+    builder: yargs => yargs
+        .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
+        .option('token', {
+            describe: 'Agent\'s token',
+        })
+        .option('agent-name', {
+            describe: 'Agent\'s name',
+        })
+        .option('storage-class-name', {
+            describe: 'Set a name of your custom storage class, note: this will not install volume provisioning components',
+        })
+        .option('runtime-kube-context-name', {
+            describe: 'Name of the kubernetes context on which the runtime should be installed (default is current-context) [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('kube-node-selector', {
+            describe: 'The kubernetes node selector "key=value" to be used by runner build resources (default is no node selector) (string)',
+        })
+        .option('docker-registry', {
+            describe: 'The prefix for the container registry that will be used for pulling the required components images. Example: --docker-registry="docker.io"',
+            type: 'string',
+        })
+        .option('set-value', {
+            describe: 'Set values for templates, example: --set-value LocalVolumesDir=/mnt/disks/ssd0/codefresh-volumes',
+        })
+        .option('set-file', {
+            describe: 'Set values for templates from file, example: --set-file Storage.GoogleServiceAccount=/path/to/service-account.json',
+        })
+        .option('dry-run', {
+            describe: 'Set to true to simulate installation',
+        })
+        .option('in-cluster', {
+            describe: 'Set flag if runner is been installed from inside a cluster',
+        })
+        .option('runtime-kube-namespace', {
+            describe: 'Name of the namespace on which runtime should be installed [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('build-annotations', {
+            describe: 'The kubernetes metadata.annotations as "key=value" to be used by runner build resources (default is no node selector)',
+        })
+        .option('runtime-kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('attach-runtime', {
+            describe: 'if set to true, auto attach runtime to agent (need to provide ....)',
+        })
+        .option('agent-kube-config-path', {
+            describe: 'Path to kubeconfig file for the agent (default is $HOME/.kube/config)',
+        })
+        .option('agent-kube-context-name', {
+            describe: 'Agent kubernetes context (on attach)',
+        })
+        .option('agent-kube-namespace', {
+            describe: 'Agent\'s namespace (on attach)',
+        })
+        .option('agent-kube-config-path', {
+            describe: 'Path to kubeconfig file for the agent (default is $HOME/.kube/config) (on attach)',
+        })
+        .option('cluster-service-account', {
+            describe: 'service account for cluster default is default',
+        })
+        .option('make-default-runtime', {
+            describe: 'should all pipelines run on the this runtime (default is false)',
+        })
+        .option('skip-cluster-creation', {
+            description: 'If set to true, will skip cluster integration creation for this runtime',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        const {
+            'storage-class-name': storageClassName,
+            'agent-name': agentName,
+            'runtime-name': reName,
+            'skip-re-creation': skipRuntimeCreation,
+            'skip-cluster-creation': skipClusterCreation,
+            'dry-run': dryRun,
+            'in-cluster': inCluster,
+            'kube-node-selector': kubeNodeSelector,
+            'runtime-kube-config-path': kubeConfigPath,
+            'set-value': setValue,
+            'set-file': setFile,
+            verbose,
+            'build-annotations': buildAnnotations,
+            'attach-runtime': attachRuntime,
+            'cluster-service-account': clusterServiceAccount,
+            'make-default-runtime': shouldMakeDefaultRe,
+            'docker-registry': dockerRegistry,
+            terminateProcess,
+        } = argv;
+
+        let {
+            'runtime-kube-context-name': kubeContextName,
+            'agent-kube-context-name': agentKubeContextName,
+            'agent-kube-namespace': agentKubeNamespace,
+            'agent-kube-config-path': agentKubeConfigPath,
+            'runtime-kube-namespace': kubeNamespace,
+            token,
+        } = argv;
+
+        if (!kubeNamespace) {
+            kubeNamespace = defaultNamespace;
+        }
+        if (attachRuntime && !agentKubeNamespace) {
+            throw new Error('agent-kube-namespace is a mandatory parameter');
+        }
+
+        // parse kubeNodeSelector in form key1=value1,key2=value2 to {key1: value1, key2: value2}
+        const kubeNodeSelectorObj = {};
+        if (kubeNodeSelector) {
+            const nsSplitParts = kubeNodeSelector.split(',');
+            nsSplitParts.forEach((nsPart) => {
+                const nsRecordSplit = nsPart.split('=');
+                if (nsRecordSplit.length !== 2) {
+                    throw new Error('invalid kube-node-selector parameter');
+                }
+                kubeNodeSelectorObj[nsRecordSplit[0]] = nsRecordSplit[1];
+            });
+        }
+
+        const apiHost = sdk.config.context.url;
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+        const clusterName = kubeContextName || getKubeContext(kubeConfigPath);
+        const runtimeName = reName || await newRuntimeName(kubeContextName, kubeNamespace);
+
+        if (!token) {
+            // eslint-disable-next-line prefer-destructuring
+            token = sdk.config.context.token;
+        }
+
+        // create RE in codefresh
+        if (!skipRuntimeCreation) {
+            await sdk.cluster.create({
+                namespace: kubeNamespace,
+                storageClassName: storageClassName || `${defaultStorageClassPrefix}-${kubeNamespace}`,
+                serviceAccount: INSTALLATION_DEFAULTS.RUNTIME_SERVICE_ACCOUNT,
+                nodeSelector: kubeNodeSelectorObj,
+                annotations: buildAnnotations,
+                clusterName,
+                runtimeEnvironmentName: runtimeName,
+                agent: true,
+            });
+            console.log(`Runtime environment "${colors.cyan(runtimeName)}" has been created`);
+            if (shouldMakeDefaultRe) {
+                const re = await sdk.runtimeEnvs.get({
+                    name: runtimeName,
+                });
+                await sdk.runtimeEnvs.setDefault({ account: re.accountId, name: re.metadata.name });
+                console.log(`Runtime environment "${colors.cyan(runtimeName)}" has been set as the default runtime`);
+            }
+        }
+
+        // check if cluster already exists
+        let createCluster = false;
+        if (!skipClusterCreation) {
+            try {
+                const clusters = await sdk.clusters.list() || [];
+                // should create cluster if it does not exist already
+                createCluster = !clusters.find(cluster => cluster.selector === kubeContextName);
+            } catch (error) {
+                console.log(`Failed to fetch account clusters, cause: ${error.message}`);
+            }
+        }
+
+        // create the cluster in codefresh if does not exists
+        if (createCluster) {
+            console.log(`Adding cluster "${colors.cyan(kubeContextName)}" integration to your Codefresh account`);
+            try {
+                await createClusterCmd.handler({
+                    'kube-context': kubeContextName,
+                    namespace: kubeNamespace,
+                    'behind-firewall': true,
+                    serviceaccount: clusterServiceAccount || 'default',
+                    terminateProcess: false,
+                });
+            } catch (error) {
+                console.log(`Failed to register cluster on Codefresh, cause: ${error.message}`);
+            }
+        }
+
+        // install RE on cluster
+        const runtimeEvents = new ProgressEvents();
+        const runtimeFormat = 'downloading runtime installer [{bar}] {percentage}% | {value}/{total}';
+        const runtimmrProgressBar = new cliProgress.SingleBar({ stopOnComplete: true, format: runtimeFormat }, cliProgress.Presets.shades_classic);
+        let runtimeTotalSize;
+        runtimeEvents.onStart((size) => {
+            console.log('Downloading runtime installer:\n');
+            runtimmrProgressBar.start(size, 0);
+            runtimeTotalSize = size;
+        });
+        runtimeEvents.onProgress((progress) => {
+            runtimmrProgressBar.update(progress);
+            if (progress >= runtimeTotalSize) {
+                console.log('\n');
+            }
+        });
+
+        const installRuntimeExitCode = await sdk.runtime.install({
+            apiHost,
+            name: runtimeName,
+            kubeContextName,
+            kubeNamespace,
+            token,
+            dryRun,
+            inCluster,
+            kubeConfigPath,
+            dockerRegistry,
+            verbose,
+            kubeNodeSelector,
+            setValue,
+            setFile,
+            terminateProcess: !attachRuntime,
+            events: runtimeEvents,
+            storageClassName: storageClassName && storageClassName.startsWith('dind-local-volumes') ? undefined : storageClassName,
+            logFormatting: DefaultLogFormatter,
+        });
+        // attach RE to agent in codefresh
+
+        if (installRuntimeExitCode !== 0) {
+            throw new Error(`Runtime environment installation failed with exit code: ${installRuntimeExitCode}`);
+        }
+
+        if (attachRuntime) {
+            // set defaults for agent options
+            if (!agentKubeNamespace) {
+                agentKubeNamespace = kubeNamespace;
+            }
+            if (!agentKubeContextName) {
+                agentKubeContextName = kubeContextName;
+            }
+            if (!agentKubeConfigPath) {
+                agentKubeConfigPath = kubeConfigPath;
+            }
+
+            const attachRuntimeStatusCode = await attachRuntimeCmd.handler({
+                'agent-name': agentName,
+                'runtime-name': runtimeName,
+                'runtime-kube-context-name': kubeContextName,
+                'runtime-kube-namespace': kubeNamespace,
+                'runtime-kube-config-path': kubeConfigPath,
+                'agent-kube-context-name': agentKubeContextName,
+                'agent-kube-namespace': agentKubeNamespace,
+                'agent-kube-config-path': agentKubeConfigPath,
+                'restart-agent': true,
+                terminateProcess,
+            });
+            if (attachRuntimeStatusCode !== 0) {
+                throw new Error(`Attach runtime failed with exit code ${attachRuntimeStatusCode}`);
+            } else {
+                return runtimeName;
+            }
+        } else {
+            console.log('Please run agent attach in order to link agent and runtime');
+        }
+    },
+});
+
+
+module.exports = installRuntimeCmd;