@sap/cds-dk 4.9.7 → 6.0.3

package/lib/init/util/templateUtil.js

@@ -146,7 +146,7 @@ module.exports = class TemplateUtil {
         const _getYAMLProperty = (object, keyPath) => keyPath.reduce((p, n) => p && p.get(n), object)
 
         const _validateConstraints = (node, dict, index) => {
-            const _addToMap = existences => existences
+            const _addToMap = existences => existences && existences
                 .filter(existence => {
                     if (!existence.in) return true
                     const neededParent = existence.in && dict.get(existence.in.ref) && dict.get(existence.in.ref).node
@@ -168,30 +168,27 @@ module.exports = class TemplateUtil {
 
         function _traverseYAMLNode(node, index, actions, templateNode) {
             let shifted = false
-            switch (node.type) {
-                case 'MAP': {
-                    actions && actions.visitMap && actions.visitMap(node, index)
-                    const [collection] = collectionStack
-                    if (collection && collection.type === 'SEQ') { collectionStack.unshift(node); shifted = true}
-                    break;
+            if (YAML.isMap(node)) {
+                actions && actions.visitMap && actions.visitMap(node, index)
+                const [collection] = collectionStack
+                if (YAML.isSeq(collection)) {
+                    collectionStack.unshift(node)
+                    shifted = true
                 }
-                case 'SEQ':
-                    break;
-                case 'PAIR':
-                    if (node.value && node.value.items) collectionStack.unshift(node.value)
-                    break;
-                case 'PLAIN':
-                    break;
+            } else if (YAML.isPair(node) && node.value && node.value.items) {
+                collectionStack.unshift(node.value)
+            } else if (YAML.isScalar(node) && semantics.forceOverwrite && templateNode) {
+                node.value = templateNode.value
             }
 
             if (node.items) {
-                if ((node.type === 'SEQ' || node.type === 'FLOW_SEQ') && templateNode && templateNode.items) {
+                if (YAML.isSeq(node) && templateNode && templateNode.items) {
                     actions.mergeCollection && actions.mergeCollection(node, templateNode)
-                    node.type === 'SEQ' && _traverseYAMLCollection(node, actions, templateNode)
+                    _traverseYAMLCollection(node, actions, templateNode)
                 } else {
                     _traverseYAMLCollection(node, actions, templateNode)
                 }
-            } else if (node.value && node.value.items) {
+            } else if (node.value && node.value.items || node.value && semantics.forceOverwrite) {
                 _traverseYAMLNode(node.value, index, actions, templateNode && templateNode.value)
             }
 
@@ -218,12 +215,12 @@ module.exports = class TemplateUtil {
                     if (templateIndex !== undefined) templateIndexMap.set(templateIndex, i)
                 }
                 if (!templateCollection) _traverseYAMLNode(node, i, actions)
-            });
+            })
 
             if (!templateCollection) return
 
             templateCollection.items.forEach((templateNode, templateIndex) => {
-                if (templateNode.type === 'PAIR') {
+                if (YAML.isPair(templateNode)) {
                     const i = keyIndexMap.get(templateNode.key.value)
                     const [collection] = collectionStack
                     const targetNode = collection.items && collection.items[i]
@@ -232,7 +229,7 @@ module.exports = class TemplateUtil {
                     } else if (actions.mergePair) {
                         actions.mergePair(collection, templateNode)
                     }
-                } else if (templateNode.type === 'MAP') {
+                } else if (YAML.isMap(templateNode)) {
                     const targetNode = collection.items[templateIndexMap.get(templateIndex)]
                     if (actions.mergeCollection) actions.mergeCollection(targetNode, templateNode)
                     if (targetNode) {
@@ -273,9 +270,9 @@ module.exports = class TemplateUtil {
             existence.collection.delete(existence.index)
 
             relationships && relationships.forEach(relationship => {
-                const parent = target.get(relationship.allWithinKeyPath[0])
+                const parent = _getYAMLProperty(target, relationship.allWithinKeyPath)
                 for (const child of parent.items) {
-                    const c = child.get(relationship.inKeyPath[0])
+                    const c = _getYAMLProperty(child, relationship.inKeyPath)
                     const i = c.items.findIndex(node =>
                         node.get(relationship.into) === _getProperty(existence.json, relationship.existenceKeyPath)
                     )
@@ -290,14 +287,13 @@ module.exports = class TemplateUtil {
         _traverseYAMLNode(target.contents, null, {
             mergePair: (collection, templateNode) => {
                 const childIsArray = false//templateNode.value.type !== 'MAP' && !!templateNode.value.items
-                if (collection.type === 'MAP' && !childIsArray) {
+                if (YAML.isMap(collection) && !childIsArray) {
                     collection.add(templateNode)
-                    //this.fsUtil.writeYAML(targetPath, target)
                 }
             },
             mergeCollection: (targetNode, templateNode) => {
-                if (templateNode.type === 'SEQ' || templateNode.type === 'FLOW_SEQ') {
-                    const [,parent] = collectionStack
+                if (YAML.isSeq(templateNode)) {
+                    let [,parent] = collectionStack
                     const missingExistences = semantics.existences
                         .filter(e => e)
                         .filter(existence => {
@@ -307,13 +303,15 @@ module.exports = class TemplateUtil {
                             return !existence.in || requiredParent === parent
 
                         })
-                        .filter(({keyPath}) => parent.get(keyPath[0]) === targetNode)
+                        .filter(({keyPath}) => {
+                            if (keyPath.length > collectionStack.length + 1) return
+                            if (keyPath.length > 1) parent = collectionStack[keyPath.length]
+                            return _getYAMLProperty(parent, keyPath) === targetNode
+                        })
                         .filter(({ref}) => !existenceMap.get(ref))
                     missingExistences.forEach(existence => {
                         const templateNode = templateExistenceMap.get(existence.ref).node
-                        templateNode.spaceBefore = existence.spaceBefore
                         targetNode.add(templateNode)
-                        //this.fsUtil.writeYAML(targetPath, target)
                     })
                 }
             },
@@ -329,7 +327,7 @@ module.exports = class TemplateUtil {
         // 7. Create missing relationships
         _traverseYAMLNode(target.contents, null, {
             mergeCollection: (targetNode, templateNode) => {
-                if (templateNode.type === 'SEQ') {
+                if (YAML.isSeq(templateNode)) {
                     const targetJSON = YAML.parse(String(targetNode))
                     const relationship = semantics.relationships && semantics.relationships
                         .filter(r => r)
@@ -347,8 +345,7 @@ module.exports = class TemplateUtil {
                         )
                         .map(({ref}) => existenceMap.get(ref).node.get(relationship.into))
                     missingPairs.forEach(pair => {
-                        targetNode.add(YAML.createNode({ [relationship.into]: pair }))
-                        //await this.fsUtil.writeYAML(targetPath, target)
+                        targetNode.add({ [relationship.into]: pair })
                     })
                 }
             }
@@ -361,5 +358,4 @@ module.exports = class TemplateUtil {
     _isObject(item) {
         return item && typeof item === 'object' && !Array.isArray(item)
     }
-};
-
+}

package/lib/k8s/ChartAdder.js

@@ -0,0 +1,65 @@
+
+
+const { yaml } = require('./modules');
+const fs = require('fs').promises;
+const FsUtil = require('../../lib/init/util/fsUtil')
+const TemplateUtil = require('../../lib/init/util/templateUtil')
+
+class ChartAdder {
+    /**
+     *
+     * @param {{ builder: import('./ChartBuilder') }} param0
+     */
+    constructor({ builder, template, chartValues, chartDependencies, app, mergeSemantics }) {
+        this.builder = builder;
+        this.template = template;
+        this.chartValues = chartValues;
+        this.app = app;
+        this.mergeSemantics = mergeSemantics;
+        this.dependencies = chartDependencies;
+        this.templateUtil = new TemplateUtil(null, new FsUtil());
+    }
+
+    async execute() {
+        await this.copyTemplates();
+        await this.addChartValues();
+        await this.addChartFile();
+    }
+
+    async copyTemplates() {
+        await this.builder.addAllTemplates(this.template);
+    }
+
+    async addChartValues() {
+        const values = this.chartValues;
+        const valuesYaml = yaml.stringify(JSON.parse(JSON.stringify(values)));
+
+        await this.builder.mergeChartFile('values.yaml', valuesYaml, this.mergeSemantics)
+    }
+
+    async addChartFile() {
+        const chart = {
+            apiVersion: 'v2',
+            name: this.app.name,
+            description: this.app.description,
+            type: 'application',
+            version: this.app.version, // should be Chart version
+            appVersion: this.app.version,
+            dependencies: this.dependencies
+        };
+
+        const header = `#
+# This file is generated by "cds add helm"
+`
+
+        const chartYaml = header + yaml.stringify(JSON.parse(JSON.stringify(chart)));
+        await this.builder.writeChartFile('Chart.yaml', chartYaml);
+    }
+
+    async getSavedValues() {
+        return yaml.parse(await fs.readFile(this.builder.chartPath('values.yaml'), 'utf-8'));
+    }
+}
+
+
+module.exports = ChartAdder;

package/lib/k8s/ChartBuilder.js

@@ -0,0 +1,186 @@
+const { cds, yaml } = require('./modules');
+const { readFileIfExists, throwError, parseMd5File, writeMd5File } = require('./util');
+const FsUtil = require('../../lib/init/util/fsUtil')
+const TemplateUtil = require('../../lib/init/util/templateUtil')
+const fs = require('fs').promises;
+const Path = require('path');
+const LOG = cds.log('k8s');
+
+/**
+ *
+ */
+
+const crypto = require('crypto');
+
+class ChartBuilder {
+    constructor({ path, rootPath = process.cwd() }) {
+        this.path = path;
+        this.rootPath = rootPath;
+        this.tackedFiles = [];
+        this.oldTrackingData = undefined;
+        this.newTrackingData = {};
+        this.templateUtil = new TemplateUtil(null, new FsUtil());
+        this.ended = false;
+    }
+
+    async begin() {
+        await this.loadOldTrackingData();
+        await this.makeDirs();
+    }
+
+    async makeDirs() {
+        await fs.mkdir(Path.join(this.path, 'templates'), { recursive: true });
+    }
+
+    async writeChartFile(fileName, data) {
+        if (this.ended) throwError `Internal Error: Cannot write file ${fileName} after end()`;
+
+        const filePath = Path.join(this.path, fileName);
+        if (!await this.checkAndWarnIfChartFileIsModified(filePath)) {
+            await fs.writeFile(filePath, data);
+        }
+        this.track(filePath, data);
+    }
+
+    async mergeChartFile(fileName, data, mergeSemantics) {
+        const filePath = Path.join(this.path, fileName);
+        const modified = await this.isChartFileModified(filePath);
+        if (modified) {
+            LOG(`Merging updates into modified file "${filePath}"`);
+            const newYamlContent = yaml.parseDocument(data);
+
+            await this.templateUtil.mergeYAML(filePath, newYamlContent, null, mergeSemantics);
+        } else {
+            await this.writeChartFile(fileName, data);
+        }
+
+        this.track(filePath, data);
+    }
+
+    async addChartFile(sourcePath, { fileName = Path.basename(sourcePath), merge = false, optional = false, mergeSemantics } = {}) {
+        if (!Path.isAbsolute(sourcePath)) {
+            sourcePath = Path.join(this.rootPath, sourcePath);
+        }
+
+        const data = await readFileIfExists(sourcePath, 'utf-8');
+        if (typeof data === "undefined") {
+            if (optional)
+                return false;
+            else
+                throwError `File *${sourcePath}* not found.`;
+        }
+
+        if (merge) {
+            await this.mergeChartFile(fileName, data, mergeSemantics);
+        } else {
+            await this.writeChartFile(fileName, data);
+        }
+
+        return true;
+    }
+
+    async addTemplate(sourcePath, sourceFileName, { targetFileName = sourceFileName, merge = false } = {}) {
+        await this.addChartFile(Path.join(sourcePath, sourceFileName), { fileName: Path.join('templates', targetFileName), merge });
+    }
+
+    async addSubchartFiles(sourceBasePath, subchart) {
+        await this.addAllFiles(sourceBasePath, Path.join('charts', subchart));
+        await this.addAllFiles(Path.join(sourceBasePath, 'templates'), Path.join('charts', subchart, 'templates'));
+    }
+
+    async addAllTemplates(sourceBasePath, templatesDir = 'templates') {
+        await this.addAllFiles(Path.join(sourceBasePath, templatesDir), 'templates');
+    }
+
+    async addAllFiles(sourcePath, targetPath = '.') {
+        await fs.mkdir(this.chartPath(targetPath), { recursive: true });
+        for (const sourceFile of await fs.readdir(sourcePath, { withFileTypes: true })) {
+            if (sourceFile.isFile()) {
+                await this.addChartFile(Path.join(sourcePath, sourceFile.name), { fileName: Path.join(targetPath, sourceFile.name) });
+            }
+        }
+    }
+
+
+    async loadOldTrackingData() {
+        this.oldTrackingData = await parseMd5File(Path.join(this.path, '.cds-add-helm-files.md5'));
+    }
+
+    async track(path, data) {
+        const key = pathKey(this.path, path);
+        this.newTrackingData[key] = hash(data);
+    }
+
+    async checkAndWarnIfChartFileIsModified(path) {
+        if (await this.isChartFileModified(path)) {
+            LOG.warn(modifiedMsg(path));
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    async isChartFileModified(path) {
+        const data = await readFileIfExists(path, 'utf-8');
+        if(data == undefined) {
+            return false;
+        }
+
+        const key = pathKey(this.path, path);
+        const currentHash = hash(data);
+        return this.oldTrackingData != undefined && this.oldTrackingData[key] != currentHash;
+    }
+
+    async end() {
+        this.ended = true;
+
+        for (const path of this.obsoleteFiles()) {
+            if (await this.isChartFileModified(path)) {
+                LOG.warn(`Kept no longer used file "${path}" because it is modified`);
+            } else {
+                LOG.warn(`Removing no longer used file "${path}" from chart`);
+                try {
+                    await fs.unlink(path);
+                } catch(error) {
+                    if (error.code !== 'ENOENT') throw error;
+                }
+            }
+        }
+
+        await this.writeNewTrackingData();
+    }
+
+    obsoleteFiles() {
+        return Object.keys(this.oldTrackingData).filter( path => !this.newTrackingData[path]).map( path => this.a(path) );
+    }
+
+    async writeNewTrackingData() {
+        await writeMd5File(Path.join(this.path, '.cds-add-helm-files.md5'), this.newTrackingData)
+    }
+
+    a(path) {
+        return Path.join(this.path, path)
+    }
+
+    chartPath(...path) {
+        return Path.join(this.path, ...path);
+    }
+}
+
+function hash(data) {
+    return crypto.createHash('md5').update(data).digest('base64');
+}
+
+function pathKey(basePath, path) {
+    return Path.posix.normalize(toPosix(Path.relative(basePath, path)))
+}
+
+function toPosix(path) {
+    return path.replace(/\\/g, '/');
+}
+
+function modifiedMsg(path) {
+    return `Chart file "${path}" has been modified and will not be updated.`;
+}
+
+module.exports = ChartBuilder;

package/lib/k8s/Context.js

@@ -0,0 +1,71 @@
+const { throwError } = require('./util');
+
+/**
+ * The context holds elements that are used to build up the CAP project. It allows
+ * decoupling between this objects. It should be used in a way that the Context is initialized
+ * with the elements (also referred to as "plugins") and each of them implements the required
+ * interface for the type of element.
+ */
+class Context {
+    constructor(objs) {
+        this.modified = true;
+        this.objs = objs || {};
+    }
+
+    async get(name) {
+        if (this.objs[name]) {
+            if (typeof this.objs[name] === 'function') {
+                this.objs[name] = await this.objs[name](this) || {};
+            }
+
+            return this.objs[name];
+        } else {
+            throwError `Unknown module *${name}*`;
+        }
+    }
+
+    async loadAll() {
+        while (this.modified) {
+            this.modified = false;
+            for (const name in this.objs) {
+                await this.get(name);
+            }
+        }
+    }
+
+    add(name, obj) {
+        this.modified = true;
+        this.objs[name] = obj;
+    }
+
+    has(name) {
+        return !!this.objs[name];
+    }
+
+    async filter(name) {
+        await this.loadAll();
+        return Object.values(this.objs).filter( obj => obj[name] );
+    }
+
+    async forEach(name, call) {
+        const filtered = await this.filter(name);
+        for (const plugin of filtered) {
+            await call(plugin);
+        }
+    }
+
+    async collect(name) {
+        let obj = {};
+        await this.forEach(name, async (plugin) => obj = {...obj, ...await plugin[name]()});
+        return Object.keys(obj).length > 0 ? obj : undefined;
+    }
+
+    async collectBool(name) {
+        let bool = false;
+        await this.forEach(name, async (plugin) => bool = bool || await plugin[name]());
+        return bool;
+    }
+
+}
+
+module.exports = Context;

package/lib/k8s/ImageUtil.js

@@ -0,0 +1,21 @@
+const { throwError } = require('./util');
+
+class ImageUtil {
+    constructor(config) {
+        this.config = config.images;
+    }
+    imageName(imageSuffix) {
+        const imagePrefix = this.config.imagePrefix || throwError `Expect *images.prefix* property.`;
+        return `${imagePrefix}-${imageSuffix}`;
+    }
+
+    get imageRegistry() {
+        return this.config.imageRegistry || throwError `Expect *images.registry* property.`;
+    }
+
+    fullImageName(suffix) {
+        return `${this.imageRegistry}/${this.imageName(suffix)}:latest`;
+    }
+}
+
+module.exports = ImageUtil;

package/lib/k8s/Model.d.ts

@@ -0,0 +1,53 @@
+
+/**
+ * CDS Kubernetes Configuration
+ */
+interface BaseConfig {
+    /** image prefix */
+    image: string,
+    cloudService: string
+}
+
+interface RegistryConfig {
+    imageRegistry: string
+}
+
+interface DeployConfig {
+    releaseName: string,
+    namespace: string,
+    imagePullSecret: string,
+    dbSecret: string,
+    domain: string
+}
+
+interface Service {
+    binding: string;
+    name: string;
+    label: string;
+}
+
+interface ApplicationModel {
+    isJava: boolean;
+    destinations: Map<string,string>; // Unfortunately today needed at build time
+    services: Service[]; // Need to know if destination service is required?
+}
+
+interface BuildModel extends BaseConfig, ApplicationModel {
+}
+
+/**
+ * Data required at image push and deploy time
+ */
+interface PushModel extends BaseConfig, RegistryConfig {
+}
+
+/**
+ * Data required at chart add time
+ */
+interface AddChartModel extends BaseConfig, ApplicationModel {
+}
+
+interface Model extends BaseConfig, ApplicationModel {
+    registry : RegistryConfig,
+    deployment : DeployConfig
+}

package/lib/k8s/auditlog/index.js

@@ -0,0 +1,29 @@
+const wrapFeature = require('../wrapFeature');
+
+module.exports = wrapFeature('auditlog', {
+    getServiceBindings() {
+        return {
+            auditlog: {
+                serviceInstanceName: 'auditlog'
+            }
+        };
+    },
+
+    getChartCapabilities() {
+        return {
+            auditlog: {
+                serviceOfferingName: 'auditlog-api',
+                servicePlanName: 'default'
+            }
+        }
+    },
+
+    async addToChart(builder, { auditlog }) {
+        await builder.addAllTemplates(__dirname);
+
+        const { config } = auditlog;
+        if (config) {
+            await builder.addChartFile(config);
+        }
+    }
+});

package/lib/k8s/auditlog/templates/auditlog.yaml

@@ -0,0 +1 @@
+{{- include "cap.service-instance" . }}

package/lib/k8s/buildModel.js

@@ -0,0 +1,70 @@
+const { throwError } = require('./util');
+const readProject = require('./readProject');
+const Path = require('path');
+
+/**
+ * Build data model of the CAP project for Kubernetes build, push, charts and chart deployment
+ *
+ * @returns
+ */
+async function buildModel(context) {
+    const k8s = await context.get('config');
+    const projectPath = await context.get('projectPath');
+
+    const project = await readProject(projectPath);
+    const cap = project.cap;
+
+    const services = buildServices(cap);
+    const isJava = typeof k8s.isJava !== 'undefined' ? k8s.isJava : cap.isJava;
+    const language = isJava ? 'Java' : 'Node';
+
+    const model = {
+        app: {
+            name: cap.appName,
+            description: cap.appDescription,
+            version: cap.appVersion
+        },
+        isMultiTenant: cap.isMultitenant,
+        isJava,
+        language,
+        services
+    }
+
+    model.getChartValues = function() {
+        return {
+            global: {
+                domain: null,
+                imagePullSecret: {
+                    name: null
+                }
+            }
+        }
+    };
+
+    model.path = function(path = '.') {
+        return Path.join(projectPath, path);
+    }
+
+    return model;
+}
+
+function buildServices(cap) {
+    const prefix = `${cap.appName}-`;
+    let services = {};
+    for (const req of cap.requires) {
+        const resource = req.resource;
+        if (!resource.name.startsWith(prefix)) throwError `Unexpected resource name _${resource.name}_. Should start with _${prefix}_`;
+        const name = resource.name.substr(prefix.length);
+
+        if (name === 'db') continue; // TODO: hard coded with srv.bindings.db.secret;
+
+        // TODO: needs improvement
+        services[name] = {
+            label: resource.service
+        };
+    }
+
+    return services;
+}
+
+module.exports = buildModel;