codefresh 0.78.2

package/lib/interface/cli/helpers/validation.js

@@ -0,0 +1,92 @@
+const _ = require('lodash');
+const yaml = require('js-yaml');
+const path = require('path');
+const { readFile, ignoreHttpError } = require('./general');
+const { sdk } = require('../../../logic');
+const CFError = require('cf-errors');
+
+
+function _buildFinalMessage(baseMessage, validationResult) {
+    if (_.isArray(validationResult)) {
+        const errors = validationResult
+            .map(({ message }) => `  - ${message}`)
+            .join('\n');
+        return `${baseMessage}:\n${errors}`;
+    }
+    return `${baseMessage}!`;
+}
+
+function _getPipelineName(filename) {
+    if (filename) {
+        return path.basename(filename, path.extname(filename));
+    }
+    return filename;
+}
+
+async function validatePipelineSpec(data) {
+    const specTemplate = _.get(data, 'spec.specTemplate');
+    const steps = _.get(data, 'spec.steps');
+    const stages = _.get(data, 'spec.stages');
+    const yamlObj = {};
+    if (data.version) {
+        yamlObj.version = data.version;
+    }
+    if (steps) {
+        yamlObj.steps = steps;
+    }
+    if (stages) {
+        yamlObj.stages = stages;
+    }
+    if (specTemplate) {  // CR-6414 Using specTemplate - skip check spec/stages - they are not used
+        return { valid: true, message: 'Using specTemplate' };
+    }
+    const validatedYaml = yaml.safeDump(yamlObj);
+    const result = await sdk.pipelines.validateYaml({ yaml: validatedYaml, outputFormat: 'lint' });
+    let message;
+    if (result.summarize) {
+        return {
+            valid: !!result.valid,
+            message: result.message,
+            warning: result.warningMessage,
+            summarize: result.summarize,
+            documentationLinks: result.documentationLinks,
+        };
+    }
+    if (!result.valid) {
+        message = _buildFinalMessage('Provided spec is not valid', result.details);
+    }
+    return { valid: !!result.valid, message };
+}
+
+async function validatePipelineYaml(filename, fileContent) {
+    const yamlContent = fileContent || await readFile(filename, 'UTF-8');
+    const name = _getPipelineName(filename);
+    const result = await sdk.pipelines.validateYaml({ yaml: yamlContent, name, outputFormat: 'lint' });
+    let message;
+    if (result.summarize) {
+        return {
+            valid: !!result.valid,
+            message: result.message,
+            warning: result.warningMessage,
+            summarize: result.summarize,
+            documentationLinks: result.documentationLinks,
+        };
+    }
+    if (!result.valid) {
+        message = _buildFinalMessage('Yaml not valid', result.details);
+    }
+    return { valid: !!result.valid, message };
+}
+
+async function checkOrProjectExists(projectName) {
+    const existing = await sdk.projects.getByName({ name: projectName }).catch(ignoreHttpError); // ignore not found error
+    if (existing) {
+        throw new CFError(`Project already exists: "${projectName}"`);
+    }
+}
+
+module.exports = {
+    validatePipelineSpec,
+    validatePipelineYaml,
+    checkOrProjectExists,
+};

package/lib/logic/cli-config/Manager.js

@@ -0,0 +1,187 @@
+const _ = require('lodash');
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const { NoPropertyError, MultiplePropertiesError, NotFullPropertyError } = require('./errors');
+
+const Model = require('./Model');
+
+const { CODEFRESH_PATH } = require('../../interface/cli/defaults');
+
+const dirPath = path.resolve(CODEFRESH_PATH, 'cli-config');
+const filePath = path.resolve(dirPath, 'config.yaml');
+
+const FALLBACK_CONFIG = {
+    currentProfile: 'default',
+    profiles: {
+        default: Model.default(),
+    },
+};
+
+let FULL_CONFIG;
+let CURRENT_CONFIG = {};
+
+/**
+ * Remove properties that not exist at schema and add default values
+ * */
+function _extractConfig(config = {}) {
+    const newConfig = {};
+    Model.properties().forEach((key) => {
+        _.set(newConfig, key, _.get(config, key));
+    });
+    return _.defaultsDeep(newConfig, Model.default());
+}
+
+function _loadFullConfig() {
+    if (!fs.existsSync(CODEFRESH_PATH)) {
+        fs.mkdirSync(CODEFRESH_PATH);
+    }
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath);
+    }
+    if (!fs.existsSync(filePath)) {
+        const fullConfig = {
+            currentProfile: 'default',
+            profiles: {
+                default: Model.default(),
+            },
+        };
+        const file = fs.openSync(filePath, 'w');
+        fs.writeSync(file, yaml.safeDump(fullConfig));
+        fs.closeSync(file);
+        return fullConfig;
+    }
+    return yaml.safeLoad(fs.readFileSync(filePath));
+}
+
+function _validate(properties, propertyName) {
+    if (!properties.length) {
+        throw new NoPropertyError(propertyName);
+    }
+    if (properties.length > 1) {
+        throw new MultiplePropertiesError(properties);
+    }
+    if (properties[0] !== propertyName) {
+        throw new NotFullPropertyError(properties[0]);
+    }
+}
+
+class CliConfigManager {
+    /**
+     * Get all available properties containing "propertyName"
+     * */
+    static get(propertyName) {
+        const properties = Model.findProperties(propertyName);
+        if (!properties.length) {
+            throw new NoPropertyError(propertyName);
+        }
+        this._preloadConfig();
+        return properties.reduce((obj, key) => {
+            _.set(obj, key, _.get(CURRENT_CONFIG, key));
+            return obj;
+        }, {});
+    }
+
+
+    static set(propertyName, value) {
+        const properties = Model.findProperties(propertyName);
+        _validate(properties, propertyName);
+        this._preloadConfig();
+        _.set(CURRENT_CONFIG, propertyName, value);
+        Model.validate(CURRENT_CONFIG);
+    }
+
+    static config() {
+        this._preloadConfig();
+        return _.cloneDeep(CURRENT_CONFIG);
+    }
+
+    static currentProfile() {
+        this._preloadConfig();
+        return FULL_CONFIG.currentProfile;
+    }
+
+    static profiles() {
+        this._preloadConfig();
+        return _.keys(FULL_CONFIG.profiles);
+    }
+
+    static availableProperties() {
+        return Model.properties();
+    }
+
+    /**
+     * Use or create a profile.
+     *
+     * @return boolean: defines whether profile was created or not
+     * */
+    static useProfile(profile) {
+        this._preloadConfig();
+        const selectedConfig = FULL_CONFIG.profiles[profile];
+        const created = !selectedConfig;
+        CURRENT_CONFIG = _extractConfig(selectedConfig);
+        FULL_CONFIG.profiles[profile] = CURRENT_CONFIG;
+        FULL_CONFIG.currentProfile = profile;
+        return created;
+    }
+
+    static persistConfig() {
+        this._preloadConfig();
+        const file = fs.openSync(filePath, 'w');
+        fs.writeSync(file, yaml.safeDump(FULL_CONFIG));
+        fs.closeSync(file);
+    }
+
+    static meta(propertyName) {
+        const meta = Model.meta();
+        return _.keys(meta)
+            .filter(key => !propertyName || !propertyName.length || key.includes(propertyName))
+            .sort()
+            .map(key => Object.assign({ key }, _.get(meta, key)));
+    }
+
+    static _preloadConfig() {
+        if (!FULL_CONFIG) {
+            this.loadConfig();
+        }
+    }
+
+    static loadConfig() {
+        try {
+            FULL_CONFIG = _loadFullConfig();
+            this.useProfile(FULL_CONFIG.currentProfile || 'default');
+            this._validateConfig();
+        } catch (e) {
+            console.warn('--------------');
+            console.warn('CLI config not loaded -- running in fallback mode.');
+            console.warn('--------------\n');
+
+            FULL_CONFIG = FALLBACK_CONFIG;
+            CURRENT_CONFIG = Model.default();
+        }
+    }
+
+    /**
+     * Replaces "broken" properties with defaults and writes to config
+     * */
+    static _validateConfig() {
+        try {
+            Model.validate(CURRENT_CONFIG);
+        } catch (e) {
+            const errorPaths = e.errors.map(er => er.dataPath.replace('.', ''));
+
+            console.warn('---------------');
+            console.warn('!!! Some properties are invalid -- replacing with defaults:');
+
+            errorPaths.forEach(ep => {
+                console.warn(ep);
+                _.set(CURRENT_CONFIG, ep, undefined);
+            });
+            console.warn('---------------\n');
+            CURRENT_CONFIG = _.defaultsDeep(CURRENT_CONFIG, Model.default());
+            CliConfigManager.persistConfig();
+        }
+    }
+}
+
+module.exports = CliConfigManager;

package/lib/logic/cli-config/Model.js

@@ -0,0 +1,82 @@
+const _ = require('lodash');
+const Ajv = require('ajv');
+const flatten = require('flat');
+
+const { SchemaValidationError } = require('./errors');
+const cliConfigSchema = require('./schema.json');
+
+const VALIDATOR = new Ajv({ coerceTypes: true, useDefaults: true });
+
+let DEFAULTS;
+let PROPERTIES;
+let PROPERTIES_META;
+
+
+/**
+ * Every schema object need to have default set to {} in order to init its properties with default value
+ * */
+function _fillSchemaObjectsWithDefault(schema) {
+    if (schema.type === 'object') {
+        schema.default = schema.default || {};
+        if (schema.properties) {
+            _.values(schema.properties).forEach((value) => {
+                if (typeof value === 'object') {
+                    _fillSchemaObjectsWithDefault(value);
+                }
+            });
+        }
+    }
+}
+
+function _compileSchema() {
+    const validate = VALIDATOR.compile(cliConfigSchema);
+    const defaults = {};
+
+    validate(defaults); // fill with default values
+    return defaults;
+}
+
+function _extractMeta(props) {
+    return props.reduce((obj, prop) => {
+        obj[prop] = prop.split('.')
+            .reduce((prev, pathPart) => prev.properties[pathPart], cliConfigSchema);
+        return obj;
+    }, {});
+}
+
+
+class Model {
+    static default() {
+        return _.cloneDeep(DEFAULTS);
+    }
+
+    static properties() {
+        return _.cloneDeep(PROPERTIES);
+    }
+
+    static findProperties(name) {
+        return PROPERTIES.filter(prop => prop.includes(name));
+    }
+
+
+    static meta() {
+        return _.cloneDeep(PROPERTIES_META);
+    }
+    /**
+     * also fills with default values and coerces types
+     * */
+    static validate(obj) {
+        if (!VALIDATOR.validate('cli-config-schema', obj)) {
+            throw new SchemaValidationError(VALIDATOR.errors);
+        }
+    }
+}
+
+_fillSchemaObjectsWithDefault(cliConfigSchema);
+
+DEFAULTS = _compileSchema();
+PROPERTIES = _.keys(flatten(DEFAULTS));
+PROPERTIES_META = _extractMeta(PROPERTIES);
+
+module.exports = Model;
+

package/lib/logic/cli-config/errors/MultiplePropertiesError.js

@@ -0,0 +1,8 @@
+class MultiplePropertiesError extends Error {
+    constructor(properties) {
+        super();
+        this.properties = properties;
+    }
+}
+
+module.exports = MultiplePropertiesError;

package/lib/logic/cli-config/errors/NoPropertyError.js

@@ -0,0 +1,8 @@
+class NoPropertyError extends Error {
+    constructor(property) {
+        super();
+        this.property = property;
+    }
+}
+
+module.exports = NoPropertyError;

package/lib/logic/cli-config/errors/NotFullPropertyError.js

@@ -0,0 +1,8 @@
+class NotFullPropertyError extends Error {
+    constructor(property) {
+        super();
+        this.property = property;
+    }
+}
+
+module.exports = NotFullPropertyError;

package/lib/logic/cli-config/errors/PipelineValidationError.js

@@ -0,0 +1,12 @@
+class PipelineValidationError extends Error {
+    constructor(message) {
+        super();
+        this.message = message;
+    }
+
+    toString() {
+        return this.message;
+    }
+}
+
+module.exports = PipelineValidationError;

package/lib/logic/cli-config/errors/SchemaValidationError.js

@@ -0,0 +1,14 @@
+class SchemaValidationError extends Error {
+    constructor(errors) {
+        super();
+        this.errors = errors;
+    }
+
+    printErrors() {
+        this.errors.forEach((e) => {
+            console.log(`Validation error: property "${e.dataPath.replace('.', '')}" ${e.message}`);
+        });
+    }
+}
+
+module.exports = SchemaValidationError;

package/lib/logic/cli-config/errors/awaitTo.js

@@ -0,0 +1,16 @@
+async function to(fn) {
+    try {
+        let res;
+        if (typeof fn === 'function') {
+            res = await fn();
+        } else {
+            res = await fn;
+        }
+        return [null, res];
+    } catch (err) {
+        return [err, null];
+    }
+}
+module.exports = {
+    to,
+};

package/lib/logic/cli-config/errors/helpers.js

@@ -0,0 +1,23 @@
+const _ = require('lodash');
+
+function prettyError(error) {
+    try {
+        const errMsg = _.get(error, 'message', error);
+        let errObj = JSON.parse(errMsg);
+        if (typeof errObj === 'string') {
+            errObj = JSON.parse(errObj);
+        }
+
+        if (!errObj.message) {
+            return error;
+        }
+
+        return errObj.code ? `${errObj.message} [code: ${errObj.code}]` : errObj.message;
+    } catch (e) {
+        return _.get(error, 'message', JSON.stringify(error));
+    }
+}
+
+module.exports = {
+    prettyError,
+};

package/lib/logic/cli-config/errors/index.js

@@ -0,0 +1,13 @@
+const NoPropertyError = require('./NoPropertyError');
+const MultiplePropertiesError = require('./MultiplePropertiesError');
+const NotFullPropertyError = require('./NotFullPropertyError');
+const SchemaValidationError = require('./SchemaValidationError');
+const PipelineValidationError = require('./PipelineValidationError');
+
+module.exports = {
+    NoPropertyError,
+    MultiplePropertiesError,
+    NotFullPropertyError,
+    SchemaValidationError,
+    PipelineValidationError,
+};

package/lib/logic/cli-config/manager.spec.js

@@ -0,0 +1,152 @@
+const _ = require('lodash');
+const path = require('path');
+
+const Manager = require('./Manager');
+const Model = require('./Model');
+
+const { CODEFRESH_PATH: mockCodefreshPath } = require('../../interface/cli/defaults');
+const mockDirPath = path.resolve(mockCodefreshPath, 'cli-config');
+const mockFilePath = path.resolve(mockDirPath, 'config.yaml');
+
+
+jest.mock('fs', () => { // eslint-disable-line
+    const readFileSync = () => this.configFile;
+    const existsSync = (path) => {
+        return {
+            [mockCodefreshPath]: true,
+            [mockDirPath]: true,
+            [mockFilePath]: this.exists,
+        }[path];
+    };
+    const openSync = () => null;
+    const writeSync = (file, config) => {
+        this.configFile = config;
+    };
+    const closeSync = () => null;
+
+    const setConfigFile = (c) => {
+        this.configFile = c;
+    };
+    const getConfigFile = () => this.configFile;
+    const setFileExists = (val) => {
+        this.exists = val;
+    };
+
+    return {
+        configFile: null,
+        exists: false,
+        existsSync,
+        readFileSync,
+        openSync,
+        closeSync,
+        writeSync,
+        setConfigFile,
+        getConfigFile,
+        setFileExists,
+    };
+});
+
+jest.mock('js-yaml', () => {
+    const safeLoad = d => d;
+    const safeDump = d => d;
+    return {
+        safeLoad,
+        safeDump,
+    };
+});
+
+jest.mock('./schema', () => { // eslint-disable-line
+    return {
+        $id: 'cli-config-schema',
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'object',
+        properties: {
+            output: {
+                type: 'object',
+                properties: {
+                    pretty: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Defines whether to show data in table view in pretty mode or not'
+                    },
+                    test: {
+                        type: 'object',
+                        properties: {
+                            first: {
+                                type: ['string', 'null'],
+                                pattern: '.*',
+                                default: null,
+                                description: 'Some empty string',
+                            },
+                            second: {
+                                type: ['string', 'null'],
+                                default: 'not empty string',
+                            },
+                        },
+                        default: {},
+                    },
+                },
+                default: {},
+            },
+        },
+    };
+});
+
+const fs = require('fs');
+
+describe('CliConfigManager', () => {
+    describe('config loading', () => {
+        // this test case must be first due to node module cache
+        it('should lazy load config', () => {
+            fs.setFileExists(true);
+            const DEFAULT_CONFIG = {
+                currentProfile: 'default',
+                profiles: {
+                    default: Model.default(),
+                },
+            };
+            fs.setConfigFile(DEFAULT_CONFIG);
+
+            Manager.config(); // lazy load
+
+            expect(Manager.config()).toEqual(Model.default());
+        });
+
+        it('should create file with default config if it not exist', () => {
+            fs.setFileExists(false);
+            fs.setConfigFile(null);
+
+            Manager.loadConfig();
+
+            const configFile = fs.getConfigFile();
+
+            expect(configFile).not.toBeNull();
+            expect(configFile.currentProfile).toBe('default');
+            expect(configFile.profiles.default).toEqual(Model.default());
+            expect(Manager.config()).toEqual(Model.default());
+        });
+    });
+
+    describe('config validation', () => {
+        it('should replace broken properties with defaults', () => {
+            const INVALID_CONFIG = {
+                currentProfile: 'default',
+                profiles: {
+                    default: {
+                        output: {
+                            pretty: 'asdf', // this must be boolean
+                        },
+                    },
+                },
+            };
+            fs.setConfigFile(INVALID_CONFIG);
+            fs.setFileExists(true);
+
+            Manager.loadConfig(); // validates config and fixes broken props
+
+            const configFile = fs.getConfigFile();
+            const prettyDefault = _.get(Model.default(), 'output.pretty');
+            expect(configFile.profiles.default.output.pretty).toBe(prettyDefault);
+        });
+    });
+});

package/lib/logic/cli-config/schema.json

@@ -0,0 +1,61 @@
+{
+    "$id": "cli-config-schema",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "output": {
+            "type": "object",
+            "properties": {
+                "pretty": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "Defines whether to show data in table view in pretty mode or not"
+                },
+                "dateFormat": {
+                    "type": "string",
+                    "enum": ["default", "date", "datetime", "date-diff"],
+                    "default": "default",
+                    "description": "Defines date format. Choices: [\"date\", \"datetime\", \"date-diff\", \"default\"] (default for resource)"
+                }
+            }
+        },
+        "request": {
+            "type": "object",
+            "properties": {
+                "timeout": {
+                    "type": "integer",
+                    "default": 30000,
+                    "description": "Defines request timeout in ms"
+                },
+                "maxAttempts": {
+                    "type": "integer",
+                    "default": 10,
+                    "description": "Defines how many times request will be retried in case of network error"
+                },
+                "retryDelay": {
+                    "type": "integer",
+                    "default": 500,
+                    "description": "Defines delay between retries in ms"
+                }
+            }
+        },
+        "logs": {
+            "type": "object",
+            "properties": {
+                "fallback": {
+                    "type": "object",
+                    "properties": {
+                        "interval": {
+                            "type": "integer",
+                            "default": 5000
+                        },
+                        "maxAttempts": {
+                            "type": "integer",
+                            "default": 1000
+                        }
+                    }
+                }
+            }
+        }
+    }
+}