support install agent (#394)

* support install agent

* wip

* install runtime

* wip

* add attach command

* add root install command

* auto attach on installer

* install agent and attach

* install agent with token

* fixes

* up

* make runtimeName mandatory

* remove agentId on install and attach

* bump sdk

* remove camel case

* add status to agent

* wip

* fix agent patch

* install agent and runtime in one command

* support agent-restart

* install runtime is opt in

* default for kube-context-name

* use kubeconfig path to resolve context

* typo

* call attach also if already agent's attached

* print token in a new line

* protect error flows

* wip

* wip

* uninstall agent

* uninstall runtime

* set defaults

Co-authored-by: Oleg Sucharevich <olegs@codefresh.io>

Author: oren-codefresh

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

@@ -53,7 +53,7 @@ const command = new Command({
             throw new CFError(`No such agent: "${name || id}"`);
         }
 
-        await sdk.agents.replace({ agentId: agent.id }, { name: newName, runtimes });
+        await sdk.agents.update({ agentId: agent.id }, { name: newName, runtimes });
         console.log(`Agent: "${name || id}" patched.`);
     },
 });

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

@@ -31,7 +31,8 @@ const command = new Command({
         } = argv;
 
         const agent = await sdk.agents.create({ name, runtimes });
-        console.log(`Agent: "${agent.name}" created with token ${agent.token}`);
+        console.log(`Agent: "${agent.name}" created`);
+        console.log(agent.token);
     },
 });
 

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

@@ -0,0 +1,144 @@
+/* eslint-disable max-len */
+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 installAgentCmd = new Command({
+    root: false,
+    parent: installRoot,
+    command: 'agent',
+    description: 'Install and create an agent on kubernetes cluster',
+    webDocs: {
+        category: 'Agents',
+        title: 'Install',
+        weight: 100,
+    },
+    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',
+        })
+        .option('token', {
+            describe: 'Agent\'s token',
+        })
+        .option('kube-context-name', {
+            describe: 'Name of the kubernetes context on which venona should be installed [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('kube-node-selector', {
+            describe: 'The kubernetes node selector "key=value" to be used by venona build resources (default is no node selector) (string)',
+        })
+        .option('dry-run', {
+            describe: 'Set to true to simulate installation',
+        })
+        .option('in-cluster', {
+            describe: 'Set flag if venona is been installed from inside a cluster',
+        })
+        .option('kube-namespace', {
+            describe: 'Name of the namespace on which venona should be installed [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('kubernetes-runner-type', {
+            describe: 'Set the runner type to kubernetes (alpha feature)',
+        })
+        .option('tolerations', {
+            describe: 'The kubernetes tolerations as path to a  JSON file to be used by venona resources (default is no tolerations) (string)',
+        })
+        .option('venona-version', {
+            describe: 'Version of venona to install (default is the latest)',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('skip-version-check', {
+            describe: 'Do not compare current Venona\'s version with latest',
+        })
+        .option('install-runtime', {
+            describe: 'Install and attach runtime on the same namespace as the agent (default is false)',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        let {
+            name, token,
+        } = argv;
+        const {
+            'kube-node-selector': kubeNodeSelector,
+            'dry-run': dryRun,
+            'in-cluster': inCluster,
+            'kube-namespace': kubeNamespace,
+            'kubernetes-runner-type': kubernetesRunnerType,
+            tolerations,
+            'venona-version': venonaVersion,
+            'kube-config-path': kubeConfigPath,
+            'skip-version-check': skipVersionCheck,
+            'install-runtime': installRuntime,
+            verbose,
+        } = argv;
+        let agent;
+        let { 'kube-context-name': kubeContextName } = argv;
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+
+        if (!token) { // Create an agent if not provided
+            name = name || `${kubeContextName}_${kubeNamespace}`;
+            agent = await sdk.agents.create({ name });
+            // eslint-disable-next-line prefer-destructuring
+            token = agent.token;
+            console.log(`An agent with name: ${name} was created\n note this the last only time the token will be printed`);
+            console.log(token);
+        } 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');
+            }
+            const { subject } = agentData;
+
+            if (subject.type !== 'agent') {
+                throw new Error('token is not assosicated with agent');
+            }
+            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 agentInstallStatusCode = await sdk.agents.install({
+            apiHost,
+            kubeContextName,
+            kubeNamespace,
+            token,
+            dryRun,
+            inCluster,
+            kubeNodeSelector,
+            kubernetesRunnerType,
+            tolerations,
+            venonaVersion,
+            kubeConfigPath,
+            skipVersionCheck,
+            verbose,
+            agentId: name,
+            terminateProcess: !installRuntime,
+        });
+        if (agentInstallStatusCode !== 0) {
+            throw new Error(`\nAgent installation failed with code ${agentInstallStatusCode}`);
+        }
+        if (installRuntime) {
+            await installRuntimeCmd.handler({
+                'runtime-kube-context-name': kubeContextName,
+                'runtime-kube-namespace': kubeNamespace,
+                'agent-name': name,
+                'runtime-kube-config-path': kubeConfigPath,
+                'attach-runtime': true,
+                'restart-agent': true,
+                verbose,
+            });
+        }
+    },
+});
+
+module.exports = installAgentCmd;

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

@@ -0,0 +1,66 @@
+/* eslint-disable max-len */
+const Command = require('../../Command');
+const deleteAgent = require('../agent/delete.cmd');
+const unInstallRoot = require('../root/uninstall.cmd');
+const { sdk } = require('../../../../logic');
+const { getKubeContext } = require('../../helpers/kubernetes');
+
+
+const unInstallAgentCmd = new Command({
+    root: false,
+    parent: unInstallRoot,
+    command: 'agent',
+    description: 'Uninstall an agent on kubernetes cluster',
+    webDocs: {
+        category: 'Agents',
+        title: 'Uninstall',
+        weight: 100,
+    },
+    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 uninstalled',
+        })
+        .option('kube-context-name', {
+            describe: 'Name of the kubernetes context on which venona should be uninstalled [$CF_ARG_KUBE_CONTEXT_NAME]',
+        })
+        .option('kube-namespace', {
+            describe: 'Name of the namespace on which venona should be uninstalled [$CF_ARG_KUBE_NAMESPACE]',
+        })
+        .option('kube-config-path', {
+            describe: 'Path to kubeconfig file (default is $HOME/.kube/config)',
+        })
+        .option('verbose', {
+            describe: 'Print logs',
+        }),
+    handler: async (argv) => {
+        const {
+            name,
+            'kube-namespace': kubeNamespace,
+            'kube-config-path': kubeConfigPath,
+
+        } = argv;
+
+        let { 'kube-context-name': kubeContextName } = argv;
+
+        if (!kubeContextName) {
+            kubeContextName = getKubeContext(kubeConfigPath);
+        }
+
+        if (!name) {
+            throw new Error('Name is a mandatory parameter');
+        }
+
+
+        await sdk.agents.unInstall({
+            name,
+            kubeContextName,
+            kubeNamespace,
+            terminateProcess: false,
+        });
+        await deleteAgent.handler({ name, id: name });
+        process.exit(0);
+    },
+});
+
+module.exports = unInstallAgentCmd;

lib/interface/cli/commands/root/install.cmd.js

@@ -0,0 +1,17 @@
+const Command = require('../../Command');
+
+
+const install = new Command({
+    root: true,
+    command: 'install',
+    description: 'Instal a resource',
+    usage: 'Install operation will install codefresh components on kubernetes cluster',
+    webDocs: {
+        description: 'Install a resource',
+        category: 'Install Resources',
+        title: 'Install',
+        weight: 40,
+    },
+});
+
+module.exports = install;

lib/interface/cli/commands/root/uninstall.cmd.js

@@ -0,0 +1,17 @@
+const Command = require('../../Command');
+
+
+const unInstall = new Command({
+    root: true,
+    command: 'uninstall',
+    description: 'Uninstal a resource',
+    usage: 'Uninstall operation will uninstall codefresh components on kubernetes cluster',
+    webDocs: {
+        description: 'Uninstall a resource',
+        category: 'Uninstall Resources',
+        title: 'Uninstall',
+        weight: 40,
+    },
+});
+
+module.exports = unInstall;

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

@@ -0,0 +1,118 @@
+/* eslint-disable max-len */
+const _ = require('lodash');
+const Command = require('../../Command');
+const { sdk } = require('../../../../logic');
+
+
+const attachAgentToRuntime = async (agent, runtime) => {
+    const runtimes = _.get(agent, 'runtimes', []);
+    const existingRT = _.find(runtimes, value => value === runtime);
+    if (!existingRT) {
+        runtimes.push(runtime);
+        await sdk.agents.update({ agentId: agent.id, runtimes });
+    }
+};
+
+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-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': restartAgent,
+            verbose,
+
+        } = 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');
+        }
+
+        await attachAgentToRuntime(agent, runtimeName);
+
+        // call venonactl to attach
+
+        await sdk.runtime.attach({
+            kubeContextName,
+            kubeNamespace,
+            kubeConfigPath,
+            agentKubeContextName,
+            agentKubeNamespace,
+            agentKubeConfigPath,
+            runtimeName,
+            verbose,
+            restartAgent,
+            terminateProcess: false,
+        });
+        if (!restartAgent) {
+            console.log('Please restart agent\'s pod in order that changes will take effect');
+        }
+        if (terminateProcess || terminateProcess === undefined) {
+            process.exit();
+        }
+    },
+});
+
+
+module.exports = attachRuntimeCmd;