codefresh 0.78.2

package/lib/interface/cli/commands/context/create/git/types/stash.cmd.js

@@ -0,0 +1,69 @@
+const debug = require('debug')('codefresh:cli:create:context:git:stash');
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const createGitCmd = require('./../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+
+const command = new Command({
+    command: 'stash <name>',
+    parent: createGitCmd,
+    description: 'Create a stash context',
+    usage: `${createGitCmd.usage}\nTo create Stash context you need to provider username and password`,
+    webDocs: {
+        category: 'Create Git Context',
+        subCategory: 'stash',
+        title: 'stash',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('username', {
+                describe: 'Username',
+                alias: 'u',
+                required: true,
+            })
+            .option('password', {
+                describe: 'Password',
+                alias: 'p',
+                required: true,
+            })
+            .option('api-url', {
+                describe: 'URL of the api',
+                alias: 'a',
+                required: true,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'git.stash',
+                data: {
+                    sharingPolicy: argv.sharingPolicy,
+                    auth: {
+                        type: 'basic',
+                        username: argv.username,
+                        password: argv.password,
+                        apiURL: argv.apiUrl,
+                    },
+                },
+            },
+        };
+
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,24 @@
+const Command = require('../../../../Command');
+const createContext = require('../../create.cmd');
+const yargs = require('yargs');
+
+const command = new Command({
+    command: 'helm-repository',
+    parent: createContext,
+    description: 'Create a helm-repository context [type]',
+    usage: '',
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Helm Repository',
+        title: 'Create Helm-Repository Context',
+    },
+    builder: (yargs) => {
+        return yargs;
+    },
+    handler: async (argv) => {
+        yargs.showHelp();
+    },
+});
+
+module.exports = command;
+

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

@@ -0,0 +1,60 @@
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const createHelmRepoCmd = require('./../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+
+const command = new Command({
+    command: 'http <name>',
+    parent: createHelmRepoCmd,
+    description: 'Create a helm-repository context from HTTP server',
+    usage: `
+    A chart repository is an HTTP server that houses an index.yaml file and optionally some packaged charts.
+    When you're ready to share your charts, the preferred way to do so is by uploading them to a chart repository.
+    Read more: https://github.com/kubernetes/helm/blob/master/docs/chart_repository.md`,
+    webDocs: {
+        category: 'Create Helm-Repository Context',
+        subCategory: 'HTTP',
+        title: 'From HTTP web server',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('url', {
+                describe: 'Url to the web server',
+                required: true,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'helm-repository',
+                data: {
+                    repositoryUrl: argv.url,
+                },
+            },
+        };
+
+        let { url } = argv;
+        const indexFileName = 'index.yaml';
+        if (url.endsWith(indexFileName)) {
+            url = url.substring(0, url.indexOf(indexFileName));
+        }
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;
+

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

@@ -0,0 +1,97 @@
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const createHelmRepoCmd = require('./../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+const AWS = {
+    keyId: {
+        awsEnvVar: 'AWS_ACCESS_KEY_ID',
+    },
+    secretKey: {
+        awsEnvVar: 'AWS_SECRET_ACCESS_KEY',
+    },
+    region: {
+        awsEnvVar: 'AWS_DEFAULT_REGION',
+    },
+};
+
+AWS.keyId.cliFlag = AWS.keyId.awsEnvVar.replace(/_/g, '-').toLowerCase();
+AWS.secretKey.cliFlag = AWS.secretKey.awsEnvVar.replace(/_/g, '-').toLowerCase();
+AWS.region.cliFlag = AWS.region.awsEnvVar.replace(/_/g, '-').toLowerCase();
+
+const command = new Command({
+    command: 's3 <name>',
+    parent: createHelmRepoCmd,
+    description: 'Create a helm-repository context from s3 bucket',
+    usage: `
+    Helm repository can be stored in AWS S3 bucket.
+    Codefresh will integrate with the bucket in the following order
+    If environment variables ${AWS.keyId.awsEnvVar}, ${AWS.secretKey.awsEnvVar} ,${AWS.region.awsEnvVar} are set, will use it to create context.
+    You can override them using flags ${AWS.keyId.cliFlag} ${AWS.secretKey.cliFlag} ${AWS.region.cliFlag}`,
+    webDocs: {
+        category: 'Create Helm-Repository Context',
+        subCategory: 'S3',
+        title: 'From AWS S3 bucket',
+        weight: 20,
+    },
+    builder: (yargs) => {
+        yargs
+            .option(AWS.keyId.cliFlag, {
+                describe: 'Amazon access key id',
+                default: process.env[AWS.keyId.awsEnvVar],
+                required: true,
+            })
+            .option(AWS.secretKey.cliFlag, {
+                describe: 'Amazon access secret key with permissions to the bucket',
+                default: process.env[AWS.secretKey.awsEnvVar],
+                required: true,
+            })
+            .option(AWS.region.cliFlag, {
+                describe: 'Amazon default region',
+                default: process.env[AWS.region.awsEnvVar],
+                required: true,
+            })
+            .option('bucket', {
+                describe: 'Name of the bucket',
+                required: true,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        let bucket = '';
+        if (argv.bucket.startsWith('s3://')) {
+            ({ bucket } = argv);
+        } else {
+            bucket = `s3://${argv.bucket}`;
+        }
+
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'helm-repository',
+                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],
+                    },
+                },
+            },
+        };
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/secret-store/base.cmd.js

@@ -0,0 +1,33 @@
+const yargs = require('yargs');
+
+const Command = require('../../../../Command');
+const createContext = require('../../create.cmd');
+
+const usage = 'Secret-Store context are used during pipeline execution as API to resolve variables that are parse of Codefresh';
+
+const command = new Command({
+    command: 'secret-store',
+    parent: createContext,
+    description: 'Create a secret-store context [type]',
+    usage,
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Secret-Store',
+        title: 'Create Secret-Store Context',
+    },
+    builder: (yargs) => {
+        yargs
+            .option('sharing-policy', {
+                describe: 'Set the sharing policy for secret-store context',
+                choices: ['AccountAdmins', 'AllUsersInAccount'],
+                default: 'AccountAdmins',
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        yargs.showHelp();
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/secret-store/types/hashicorp-vault.cmd.js

@@ -0,0 +1,141 @@
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const cmd = require('../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+function buildAuthObject({ loginPath, namespace, token, username, password, roleId, secretId, gcpRole, kubernetesRole, kubernetesJwt }) {
+    const baseAuth = {
+        ...(loginPath && { mount_point: loginPath }),
+        ...(namespace && { namespace }),
+    };
+    if (token) {
+        return { type: 'token', token, ...baseAuth };
+    }
+
+    if (username && password) {
+        return { type: 'userpass', username, password, ...baseAuth };
+    }
+
+    if (roleId && secretId) {
+        return { type: 'approle', role_id: roleId, secret_id: secretId, ...baseAuth };
+    }
+
+    if (gcpRole) {
+        return { type: 'gcp', roleType: 'gce', role: gcpRole, ...baseAuth };
+    }
+
+    if (kubernetesRole) {
+        return {
+            type: 'kubernetes',
+            role: kubernetesRole,
+            ...(kubernetesJwt && { jwt: kubernetesJwt }),
+            ...baseAuth,
+        };
+    }
+
+    throw new CFError('missing authentication info');
+}
+
+const command = new Command({
+    command: 'hashicorp-vault <name>',
+    parent: cmd,
+    description: 'Create a Hashicorp Vault secret-store context',
+    usage: cmd.usage,
+    webDocs: {
+        category: 'Create Secret-Store Context',
+        subCategory: 'hashicorp-vault',
+        title: 'hashicorp-vault',
+        weight: 10,
+    },
+    builder(yargs) {
+        return yargs
+            .option('behind-firewall', {
+                describe: 'Set to true to mark this context with behind firewall flag',
+                type: 'boolean',
+                default: false,
+            })
+            .option('api-url', {
+                alias: 'a',
+                describe: 'URL of the vault server',
+                type: 'string',
+                required: true,
+            })
+            .option('login-path', {
+                describe: 'Path for given auth method. Leave out to use the default path for the type.',
+                type: 'string',
+            })
+            .option('namespace', {
+                alias: 'n',
+                describe: 'Namespace is only valid for Vault Enterprise instances',
+                type: 'string',
+            })
+            .option('token', {
+                alias: 't',
+                describe: 'Token',
+                type: 'string',
+                conflicts: ['username', 'password', 'roleId', 'secretId', 'gcp-role', 'kubernetes-role', 'kubernetes-jwt'],
+            })
+            .option('username', {
+                describe: 'Username',
+                alias: 'u',
+                type: 'string',
+                conflicts: ['token', 'roleId', 'secretId', 'gcp-role', 'kubernetes-role', 'kubernetes-jwt'],
+            })
+            .option('password', {
+                describe: 'Password',
+                alias: 'p',
+                type: 'string',
+                conflicts: ['token', 'roleId', 'secretId', 'gcp-role', 'kubernetes-role', 'kubernetes-jwt'],
+            })
+            .option('role-id', {
+                describe: 'Role Id',
+                alias: 'r',
+                type: 'string',
+                conflicts: ['token', 'username', 'password', 'gcp-role', 'kubernetes-role', 'kubernetes-jwt'],
+            })
+            .option('secret-id', {
+                describe: 'Secret Id',
+                alias: 's',
+                type: 'string',
+                conflicts: ['token', 'username', 'password', 'gcp-role', 'kubernetes-role', 'kubernetes-jwt'],
+            })
+            .option('gcp-role', {
+                describe: 'GCP Role',
+                type: 'string',
+                conflicts: ['token', 'username', 'password', 'role-id', 'secret-id', 'kubernetes-role', 'kubernetes-jwt'],
+            })
+            .option('kubernetes-role', {
+                describe: 'Kubernetes Role',
+                type: 'string',
+                conflicts: ['token', 'username', 'password', 'role-id', 'secret-id', 'gcp-role'],
+            })
+            .option('kubernetes-jwt', {
+                describe: 'Kubernetes Role',
+                type: 'string',
+                conflicts: ['token', 'username', 'password', 'role-id', 'secret-id', 'gcp-role'],
+            })
+            .check(buildAuthObject);
+    },
+    async handler(argv) {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'secret-store.hashicorp-vault',
+                data: {
+                    sharingPolicy: argv.sharingPolicy,
+                    behindFirewall: argv.behindFirewall,
+                    apiUrl: argv.apiUrl,
+                    auth: buildAuthObject(argv),
+                },
+            },
+        };
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/context/create/secret-store/types/kubernetes-runtime.cmd.js

@@ -0,0 +1,67 @@
+const debug = require('debug')('codefresh:cli:create:context:secret-store:kubernetes');
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const cmd = require('../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+const command = new Command({
+    command: 'kubernetes-runtime <name>',
+    parent: cmd,
+    description: 'Create a secret-store Kubernetes-Runtime context',
+    usage: 'Create a secret store to use hybrid runtime to access K8S secret/configmap and use it as secret store',
+    webDocs: {
+        category: 'Create Secret-Store Context',
+        subCategory: 'kubernetes-Runtime',
+        title: 'kubernetes-runtime',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('runtimes', {
+                describe: 'Names of the runtime-environment to be used as secret store',
+                type: 'array',
+                alias: 'runtime',
+                default: ['*'],
+            })
+            .option('resource-type', {
+                describe: 'Type of the resource in Kubernetes',
+                required: true,
+                choices: ['secret', 'configmap'],
+            })
+            .option('resource-name', {
+                describe: 'Name of the resource in Kubernetes',
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        let runtimes = [];
+        if (argv.runtime) {
+            runtimes = argv.runtimes;
+        }
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'secret-store.kubernetes-runtime',
+                data: {
+                    sharingPolicy: argv.sharingPolicy,
+                    resourceType: argv.resourceType,
+                    resourceName: argv.resourceName,
+                    runtimes,
+                },
+            },
+        };
+
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/context/create/secret-store/types/kubernetes.cmd.js

@@ -0,0 +1,67 @@
+const debug = require('debug')('codefresh:cli:create:context:secret-store:kubernetes');
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const cmd = require('../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+const command = new Command({
+    command: 'kubernetes <name>',
+    parent: cmd,
+    description: 'Create a secret-store Kubernetes context',
+    usage: cmd.usage,
+    webDocs: {
+        category: 'Create Secret-Store Context',
+        subCategory: 'kubernetes',
+        title: 'kubernetes',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('cluster', {
+                describe: 'Name of the Kubernetes clsuter as it saved in Codefresh',
+                required: true,
+            })
+            .option('namespace', {
+                describe: 'Name of the Kubernetes namespace',
+                required: true,
+                default: 'default',
+            })
+            .option('resource-type', {
+                describe: 'Type of the resource in Kubernetes',
+                required: true,
+                choices: ['secret', 'configmap'],
+            })
+            .option('resource-name', {
+                describe: 'Name of the resource in Kubernetes',
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'secret-store.kubernetes',
+                data: {
+                    sharingPolicy: argv.sharingPolicy,
+                    resourceType: argv.resourceType,
+                    resourceName: argv.resourceName,
+                    cluster: argv.cluster,
+                    namespace: argv.namespace,
+                },
+            },
+        };
+
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;

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

@@ -0,0 +1,23 @@
+const Command = require('../../Command');
+const createRoot = require('../root/create.cmd');
+const yargs = require('yargs');
+
+const command = new Command({
+    command: 'context',
+    aliases: ['ctx'],
+    parent: createRoot,
+    description: 'Create a context',
+    webDocs: {
+        category: 'Contexts',
+        title: 'Create Context',
+    },
+    builder: (yargs) => {
+        return yargs;
+    },
+    handler: async (argv) => {
+        yargs.showHelp();
+    },
+});
+
+module.exports = command;
+

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

@@ -0,0 +1,39 @@
+const debug = require('debug')('codefresh:cli:create:context');
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const deleteRoot = require('../root/delete.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const { sdk } = require('../../../../logic');
+
+const command = new Command({
+    command: 'context [name]',
+    aliases: ['ctx'],
+    parent: deleteRoot,
+    description: 'Delete a context',
+    webDocs: {
+        category: 'Contexts',
+        title: 'Delete Context',
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        return yargs
+            .positional('name', {
+                describe: 'Name of context',
+            })
+            .example('codefresh delete context NAME', 'Delete context NAME');
+    },
+    handler: async (argv) => {
+        const name = argv.filename ? _.get(argv.filename, 'metadata.name') : argv.name;
+
+        if (!name) {
+            throw new CFError('Name must be provided');
+        }
+
+        await sdk.contexts.delete({ name });
+        console.log(`Context: ${name} deleted`);
+    },
+});
+
+module.exports = command;
+