codefresh 0.84.9 → 0.85.0

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

@@ -1,17 +1,160 @@
 /* eslint-disable max-len */
+const cliProgress = require('cli-progress');
+const colors = require('colors');
 const Command = require('../../Command');
 const installRoot = require('../root/install.cmd');
 const { sdk } = require('../../../../logic');
 const installRuntimeCmd = require('../runtimeEnvironments/install.cmd');
 const { getKubeContext } = require('../../helpers/kubernetes');
 const ProgressEvents = require('../../helpers/progressEvents');
-const cliProgress = require('cli-progress');
-const colors = require('colors');
 const { getNewAgentName } = require('./helper');
-const { DefaultLogFormatter } = require('./../hybrid/helper');
+const { DefaultLogFormatter } = require('../hybrid/helper');
+const Output = require('../../../../output/Output');
 
 const defaultNamespace = 'codefresh';
 
+async function createAgent(argv) {
+    const {
+        name,
+        kubeConfigPath,
+        kubeContextName = getKubeContext(kubeConfigPath),
+        kubeNamespace = defaultNamespace,
+    } = argv;
+    const finalName = name || await getNewAgentName(kubeContextName, kubeNamespace);
+    try {
+        const { token } = await sdk.agents.create({ name: finalName });
+        console.log(`A Codefresh Runner with the name: ${colors.cyan(finalName)} has been created.`);
+        return token;
+    } catch (err) {
+        const msg = Output._extractErrorMessage(err);
+        if (msg.includes('Agent name duplication')) {
+            throw new Error(`A Codefresh Runner with the name "${colors.cyan(finalName)}" already exists. Please choose a different name, or delete the current agent from the platform.`);
+        }
+
+        throw err;
+    }
+}
+
+async function getAgentNameByToken(token) {
+    const [apiKey] = token.split('.');
+    const agentData = await sdk.tokens.getById({ id: apiKey });
+    if (!agentData) {
+        throw new Error('token is not valid');
+    }
+
+    const {
+        subject: {
+            type,
+            ref,
+        },
+    } = agentData;
+
+    if (type !== 'agent') {
+        throw new Error('token is not assosicated with a runner');
+    }
+
+    const { name } = await sdk.agents.get({ agentId: ref });
+    return name;
+}
+
+async function installAgentInCluster(argv, token, agentName) {
+    const {
+        kubeNodeSelector,
+        dryRun,
+        inCluster,
+        tolerations,
+        dockerRegistry,
+        skipVersionCheck,
+        kubeConfigPath,
+        kubeContextName = getKubeContext(kubeConfigPath),
+        kubeNamespace = defaultNamespace,
+        envVars,
+        verbose,
+        terminateProcess,
+    } = argv;
+
+    const apiHost = sdk.config.context.url;
+    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) => {
+        console.log('Downloading Codefresh Runner installer \n');
+        progressBar.start(size, 0);
+        totalSize = size;
+    });
+    events.onProgress((progress) => {
+        progressBar.update(progress);
+        if (progress >= totalSize) {
+            console.log('\n');
+        }
+    });
+    const agentInstallStatusCode = await sdk.agents.install({
+        agentId: agentName,
+        apiHost,
+        token,
+        kubeConfigPath,
+        kubeContextName,
+        kubeNamespace,
+        kubeNodeSelector,
+        inCluster,
+        dockerRegistry,
+        tolerations,
+        skipVersionCheck,
+        envVars,
+        events,
+        dryRun,
+        verbose,
+        terminateProcess,
+        logFormatting: DefaultLogFormatter,
+    });
+    if (agentInstallStatusCode !== 0) {
+        throw new Error(`\nRunner installation failed with code ${agentInstallStatusCode}`);
+    }
+}
+
+async function installRuntimeFunc(argv, agentName) {
+    const {
+        runtimeName,
+        skipReCreation,
+        buildNodeSelector,
+        storageClassName,
+        setValue,
+        setFile,
+        agentKubeContextName,
+        agentKubeNamespace,
+        kubeConfigPath,
+        kubeContextName,
+        kubeNamespace,
+        skipClusterCreation,
+        makeDefaultRuntime,
+        platformOnly,
+        verbose,
+        terminateProcess,
+    } = argv;
+    await installRuntimeCmd.handler({
+        runtimeName,
+        skipReCreation,
+        skipClusterCreation,
+        runtimeKubeConfigPath: kubeConfigPath,
+        runtimeKubeContextName: kubeContextName,
+        runtimeKubeNamespace: kubeNamespace,
+        kubeNodeSelector: buildNodeSelector,
+        storageClassName,
+        setValue,
+        setFile,
+        makeDefaultRuntime,
+        attachRuntime: true,
+        agentName,
+        agentKubeContextName,
+        agentKubeNamespace,
+        restartAgent: true,
+        platformOnly,
+        verbose,
+        terminateProcess,
+    });
+}
+
 const installAgentCmd = new Command({
     root: false,
     parent: installRoot,
@@ -22,7 +165,7 @@ const installAgentCmd = new Command({
         title: 'Install',
         weight: 100,
     },
-    builder: yargs => yargs
+    builder: (yargs) => yargs
         .env('CF_ARG_') // this means that every process.env.CF_ARG_* will be passed to argv
         .option('name', {
             describe: 'Agent\'s name to be created if token is not provided',
@@ -57,6 +200,24 @@ const installAgentCmd = new Command({
         .option('install-runtime', {
             describe: 'Install and attach runtime on the same namespace as the agent (default is false)',
         })
+        .option('runtime-name', {
+            describe: 'The name of the runtime to install',
+        })
+        .option('build-node-selector', {
+            describe: 'The kubernetes node selector "key=value" to be used by runner build resources (default is no node selector) (string)',
+        })
+        .option('skip-re-creation', {
+            description: 'If set to true, will skip runtime creation in the platform',
+        })
+        .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('skip-cluster-creation', {
+            description: 'If set to true, will skip cluster integration creation for this runtime',
+        })
         .option('make-default-runtime', {
             describe: 'should all pipelines run on the hybrid runtime (default is false)',
         })
@@ -73,132 +234,49 @@ const installAgentCmd = new Command({
             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('platform-only', {
+            describe: 'Set to true to create runtime on the platform side only',
+        })
         .option('verbose', {
             describe: 'Print logs',
         }),
     handler: async (argv) => {
-        let {
-            name, token,
-        } = argv;
         const {
-            'runtime-name': reName,
-            'skip-re-creation': skipRuntimeCreation,
-            'kube-node-selector': kubeNodeSelector,
-            'build-node-selector': buildNodeSelector,
-            'dry-run': dryRun,
-            'in-cluster': inCluster,
-            tolerations,
-            'kube-config-path': kubeConfigPath,
-            'skip-version-check': skipVersionCheck,
-            'install-runtime': installRuntime,
-            'make-default-runtime': shouldMakeDefaultRe,
-            'storage-class-name': storageClassName,
-            verbose,
-            terminateProcess,
-            'set-value': setValue,
-            'set-file': setFile,
-            'agent-kube-context-name': agentKubeContextName,
-            'agent-kube-namespace': agentKubeNamespace,
-            'docker-registry': dockerRegistry,
-            envVars,
+            agentKubeNamespace,
+            installRuntime,
+            platformOnly,
         } = argv;
-        let agent;
         let {
-            'kube-context-name': kubeContextName,
-            'kube-namespace': kubeNamespace,
+            name,
+            token,
         } = argv;
-        if (!kubeContextName) {
-            kubeContextName = getKubeContext(kubeConfigPath);
-        }
-        if (!kubeNamespace) {
-            kubeNamespace = defaultNamespace;
-        }
-        if (installRuntime && !agentKubeNamespace) {
+
+        if (installRuntimeFunc && !agentKubeNamespace) {
             throw new Error('agent-kube-namespace is a mandatory parameter when installing runtime');
         }
 
-        if (!token) { // Create an agent if not provided
-            name = name || await getNewAgentName(kubeContextName, kubeNamespace);
-            agent = await sdk.agents.create({ name });
-            // eslint-disable-next-line prefer-destructuring
-            token = agent.token;
-            console.log(`A Codefresh Runner with the name: ${colors.cyan(name)} has been created.`);
+        if (!token) {
+            // Create an agent if not provided
+            token = await createAgent(argv);
         } else {
-            // take the agent id from the token
-            const apiKey = token.split('.')[0];
-            const agentData = await sdk.tokens.getById({ id: apiKey });
-            if (!agentData) {
-                throw new Error('token is not valid');
+            // take the agent name from the token
+            const nameFromToken = await getAgentNameByToken(token);
+            if (!name) {
+                name = nameFromToken;
+            } else if (name !== nameFromToken) {
+                throw new Error(`token is assosicated with agent ${nameFromToken}, different from supplied '--name ${name}'`);
             }
-            const { subject } = agentData;
-
-            if (subject.type !== 'agent') {
-                throw new Error('token is not assosicated with a runner');
-            }
-            const agentId = agentData.subject.ref;
-            const data = await sdk.agents.get({ agentId });
-            // eslint-disable-next-line prefer-destructuring
-            name = data.name;
         }
-        const apiHost = sdk.config.context.url;
-        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) => {
-            console.log('Downloading Codefresh Runner installer \n');
-            progressBar.start(size, 0);
-            totalSize = size;
-        });
-        events.onProgress((progress) => {
-            progressBar.update(progress);
-            if (progress >= totalSize) {
-                console.log('\n');
-            }
-        });
-        const agentInstallStatusCode = await sdk.agents.install({
-            apiHost,
-            kubeContextName,
-            kubeNamespace,
-            token,
-            dryRun,
-            inCluster,
-            kubeNodeSelector,
-            dockerRegistry,
-            tolerations,
-            kubeConfigPath,
-            skipVersionCheck,
-            verbose,
-            agentId: name,
-            terminateProcess,
-            events,
-            logFormatting: DefaultLogFormatter,
-            envVars,
-        });
-        if (agentInstallStatusCode !== 0) {
-            throw new Error(`\nRunner installation failed with code ${agentInstallStatusCode}`);
+
+        if (!platformOnly) {
+            await installAgentInCluster(argv, token, name);
         }
+
         if (installRuntime) {
-            return installRuntimeCmd.handler({
-                'runtime-name': reName,
-                'skip-re-creation': skipRuntimeCreation,
-                'runtime-kube-context-name': kubeContextName,
-                'runtime-kube-namespace': kubeNamespace,
-                'agent-name': name,
-                'runtime-kube-config-path': kubeConfigPath,
-                'attach-runtime': true,
-                'restart-agent': true,
-                'make-default-runtime': shouldMakeDefaultRe,
-                'kube-node-selector': buildNodeSelector,
-                'storage-class-name': storageClassName,
-                'set-value': setValue,
-                'set-file': setFile,
-                'agent-kube-namespace': agentKubeNamespace,
-                'agent-kube-context-name': agentKubeContextName,
-                verbose,
-                terminateProcess,
-            });
+            await installRuntimeFunc(argv, name);
         }
+
+        console.log(token);
     },
 });
 

package/lib/interface/cli/commands/context/context.sdk.spec.js

@@ -6,7 +6,6 @@ const request = require('requestretry');
 
 jest.mock('../../../../logic/entities/Context');
 
-
 const DEFAULT_RESPONSE = request.__defaultResponse();
 
 describe('context commands', () => {
@@ -80,7 +79,13 @@ describe('context commands', () => {
             describe('s3', () => {
                 it('should handle creation', async () => {
                     const cmd = require('./create/helm-repo/types/s3.cmd');
-                    const argv = { name: 'some name', bucket: 'some bucket' };
+                    const argv = {
+                        name: 'some name',
+                        bucket: 'some bucket',
+                        'aws-access-key-id': 'test-id',
+                        'aws-secret-access-key': 'test-secret',
+                        'aws-default-region': 'test-region',
+                    };
                     await cmd.handler(argv);
                     await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
                 });

package/lib/interface/cli/commands/context/create/helm-repo/types/s3.cmd.js

@@ -37,19 +37,14 @@ const command = new Command({
     builder: (yargs) => {
         yargs
             .option(AWS.keyId.cliFlag, {
-                describe: 'Amazon access key id',
-                default: process.env[AWS.keyId.awsEnvVar],
-                required: true,
+                describe: `Amazon access key id [default: ${AWS.keyId.awsEnvVar} env]`,
+
             })
             .option(AWS.secretKey.cliFlag, {
-                describe: 'Amazon access secret key with permissions to the bucket',
-                default: process.env[AWS.secretKey.awsEnvVar],
-                required: true,
+                describe: `Amazon access secret key with permissions to the bucket [default: ${AWS.secretKey.awsEnvVar} env]`,
             })
             .option(AWS.region.cliFlag, {
-                describe: 'Amazon default region',
-                default: process.env[AWS.region.awsEnvVar],
-                required: true,
+                describe: `Amazon default region [default: ${AWS.region.awsEnvVar} env]`,
             })
             .option('bucket', {
                 describe: 'Name of the bucket',
@@ -58,6 +53,25 @@ const command = new Command({
         return yargs;
     },
     handler: async (argv) => {
+        const awsKeyId = argv[AWS.keyId.cliFlag] || process.env[AWS.keyId.awsEnvVar];
+        const awsSecretKey = argv[AWS.secretKey.cliFlag] || process.env[AWS.secretKey.awsEnvVar];
+        const awsRegion = argv[AWS.region.cliFlag] || process.env[AWS.region.awsEnvVar];
+        if (!awsKeyId) {
+            throw new CFError({
+                message: `Either ${AWS.keyId.awsEnvVar} env, or --${AWS.keyId.cliFlag} option is required`,
+            });
+        }
+        if (!awsSecretKey) {
+            throw new CFError({
+                message: `Either ${AWS.secretKey.awsEnvVar} env, or --${AWS.secretKey.cliFlag} option is required`,
+            });
+        }
+        if (!awsRegion) {
+            throw new CFError({
+                message: `Either ${AWS.region.awsEnvVar} env, or --${AWS.region.cliFlag} option is required`,
+            });
+        }
+
         let bucket = '';
         if (argv.bucket.startsWith('s3://')) {
             ({ bucket } = argv);
@@ -76,9 +90,9 @@ const command = new Command({
                 data: {
                     repositoryUrl: bucket,
                     variables: {
-                        [AWS.keyId.awsEnvVar]: argv[AWS.keyId.cliFlag],
-                        [AWS.secretKey.awsEnvVar]: argv[AWS.secretKey.cliFlag],
-                        [AWS.region.awsEnvVar]: argv[AWS.region.cliFlag],
+                        [AWS.keyId.awsEnvVar]: awsKeyId,
+                        [AWS.secretKey.awsEnvVar]: awsSecretKey,
+                        [AWS.region.awsEnvVar]: awsRegion,
                     },
                 },
             },

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

@@ -1,27 +1,107 @@
 /* eslint-disable max-len */
 const _ = require('lodash');
+const cliProgress = require('cli-progress');
 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 { DefaultLogFormatter } = require('../hybrid/helper');
+
+async function attachInPlatform(argv) {
+    const {
+        agentName,
+        agentId,
+        runtimeName,
+    } = argv;
+    let agent;
+    if (_.isEmpty(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');
+    }
 
-const attachAgentToRuntime = async (agent, name) => {
-    const rt = await sdk.runtimeEnvs.get({ name });
+    const rt = await sdk.runtimeEnvs.get({ name: runtimeName });
     if (!rt) {
-        throw new Error(`runtime ${name} does not exist on the account`);
+        throw new Error(`runtime ${runtimeName} 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);
+    const existingRT = _.find(runtimes, (value) => value === runtimeName);
     if (!existingRT) {
-        runtimes.push(name);
+        runtimes.push(runtimeName);
         await sdk.agents.update({ agentId: agent.id, runtimes });
     }
-};
+}
+
+async function attachInCluster(argv) {
+    const {
+        runtimeName,
+        runtimeKubeConfigPath,
+        runtimeKubeContextName = getKubeContext(runtimeKubeConfigPath),
+        runtimeKubeNamespace,
+        agentKubeConfigPath,
+        agentKubeContextName = runtimeKubeContextName,
+        agentKubeNamespace,
+        runtimeKubeServiceAccount,
+        restartAgent,
+        verbose,
+    } = argv;
+    if (_.isNull(runtimeName) || _.isUndefined(runtimeName) || runtimeName === '') {
+        throw new Error('runtime name is mandatory');
+    }
+
+    if (!runtimeKubeNamespace) {
+        throw new Error('runtime-kube-namespace is mandatory parameter');
+    }
+
+    // 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({
+        runtimeName,
+        kubeConfigPath: runtimeKubeConfigPath,
+        kubeContextName: runtimeKubeContextName,
+        kubeNamespace: runtimeKubeNamespace,
+        kubeServiceAccount: runtimeKubeServiceAccount,
+        agentKubeConfigPath,
+        agentKubeContextName,
+        agentKubeNamespace,
+        verbose,
+        restartAgent,
+        terminateProcess: false,
+        events,
+        logFormatting: DefaultLogFormatter,
+    });
+    if (!restartAgent) {
+        console.log('Please restart agent\'s pod in order that changes will take effect');
+    }
+}
 
 const attachRuntimeCmd = new Command({
     root: true,
@@ -33,7 +113,7 @@ const attachRuntimeCmd = new Command({
         title: 'Attach Runtime-Environments',
         weight: 100,
     },
-    builder: yargs => yargs
+    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',
@@ -59,101 +139,42 @@ const attachRuntimeCmd = new Command({
         .option('agent-kube-namespace', {
             describe: 'Agent\'s namespace',
         })
+        .option('agent-kube-service-account', {
+            describe: 'The service account to use for the agent pod',
+        })
         .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('platform-only', {
+            describe: 'Set to true to attach runtime to agent on the platform side only',
+        })
         .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,
-
+            runtimeKubeNamespace,
+            platformOnly,
+            terminateProcess,
         } = 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) {
+        if (!runtimeKubeNamespace && !platformOnly) {
             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');
+        await attachInPlatform(argv);
+        if (!platformOnly) {
+            await attachInCluster(argv);
         }
+
         if (terminateProcess || terminateProcess === undefined) {
             process.exit();
-        } else {
-            return 0;
         }
+
+        return 0;
     },
 });
 
-
 module.exports = attachRuntimeCmd;