@kumologica/sdk 3.2.0-beta9 → 4.0.0-alpha2

package/src/api/tools/debugger/index.js

@@ -0,0 +1,193 @@
+const { DesignerTool } = require('../base/DesignerTool');
+const { TestCaseRunner, InMemoryReporter } = require('../test/lib/TestCaseRunner');
+
+const DEBUGGER_PLUGIN = 'DebuggerPlugin';
+
+/**
+ * 
+ * Commands:
+ * { type: 'debugger:start', payload: { testcaseid: '2343.3434', breakpoints: {'123.1231', '1231.123'}}
+ * { type: 'debugger:continue' }
+ * { type: 'debugger:next' }
+ * { type: 'debugger:terminate' }
+ * 
+ * Events:
+ * { type: 'debugger:on:trace', payload: { step: 1, type: 'input|output|error', message: {...}, vars: {} }}
+ * { type: 'debugger:on:change-state', payload: { step: 2, from: 'running', to: 'paused'}}
+ * { type: 'debugger:on:event', { status: "startFlow" });
+ * 
+ * Responses:
+ * { type: 'debugger:start:response', "payload": { "testCaseExecutionTimeInMs": 1.7501250505447388, "testCaseID": "e8fb91dc.46c24",  "testCaseDescription": "TestCase HelloWorld", "assertions": [... ] } }
+ */
+class DebuggerTool extends DesignerTool {
+    constructor(designerServer) {
+        super(designerServer);
+    }
+
+    install() {
+        this.addEventHandler('debugger:start', this.start('debugger:start'));
+        this.addEventHandler('debugger:next', this.next('debugger:next'));
+        this.addEventHandler('debugger:continue', this.continue('debugger:continue'));
+        this.addEventHandler('debugger:terminate', this.terminate('debugger:terminate'));
+    }
+
+
+    start(eventType) {
+        return async (ws, payload) => {
+            const { testcaseid, breakpoints } = payload;
+            // runtime -> tool -> sdk
+            let debuggerListener = this.debuggerEventListener(ws);
+
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+
+                // Subscribe to debugger plugin events
+                this.subscribeRuntimeListener(debuggerListener);
+
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.ENABLE, breakpoints);
+
+                // Execute the flow as a test
+                const reporter = new InMemoryReporter();
+                const runner = new TestCaseRunner(this.flowServer, testcaseid, [reporter]);
+                await runner.runAsync();
+                let response = {
+                    testCaseExecutionTimeInMs: reporter.executionTimeInMs,
+                    testCaseID: reporter.testCaseID,
+                    testCaseDescription: reporter.testCaseDescription,
+                    assertions: reporter.assertionResults
+                }
+                this.sendResponse(ws, eventType, response);
+
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            } finally {
+                this.clearRuntimeListener(debuggerListener);
+            }
+
+        }
+    }
+
+    next(eventType) {
+        return async (ws, payload) => {
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.NEXT);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        };
+    }
+
+    continue(eventType) {
+        return async (ws, payload) => {
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.CONTINUE);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        };
+    }
+
+    terminate(eventType) {
+        return async (ws, payload) => {
+            try {
+                if (!this.isRuntimePluginInstalled(DEBUGGER_PLUGIN)) {
+                    throw new Error("DebuggerPlugin not installed");
+                }
+                let pluginCommands = this.getRuntimePlugin(DEBUGGER_PLUGIN).listCommands();
+                // Send command to get ready the debugger plugin  
+                this.sendCommandToPlugin(DEBUGGER_PLUGIN, pluginCommands.TERMINATE);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        };
+    }
+
+    debuggerEventListener(ws) {
+        return (event) => {
+            let payload = event.payload;
+
+            switch (event.id) {
+                case 'runtime-event://debuggerPlugin/startFlow':
+                    this.sendEvent(ws, 'debugger:on:event', { status: "startFlow" });
+                    break;
+                case 'runtime-event://debuggerPlugin/endFlow':
+                    this.sendEvent(ws, 'debugger:on:event', { status: "endFlow" });
+                    break;
+                case 'runtime-event://debuggerPlugin/errorFlow':
+                    this.sendEvent(ws, 'debugger:on:event', { status: "errorFlow" });
+                    break;
+
+                case 'runtime-event://debuggerPlugin/startNode':
+                case 'runtime-event://debuggerPlugin/endNode':
+                case 'runtime-event://debuggerPlugin/errorNode':
+                    this.sendEvent(ws, 'debugger:on:trace', payload);
+                    break;
+
+                case 'runtime-event://debuggerPlugin/changeState':
+                    this.sendEvent(ws, 'debugger:on:change-state', payload);
+                    break;
+                default:
+                // do nothing
+            }
+        }
+
+    };
+
+    // NOT NEEDED YET
+    // genNextUniqueId(node, testcaseid) {
+    //     let uniqueExecutionNodeId;
+    //     let id = node.id;
+    //     // check if node.id has not yet injected with unique runtime id
+    //     if (!id.includes('::')){
+    //       uniqueExecutionNodeId = `${testcaseid}::${node.id}::0`;
+    //     } else{
+    //       // Replace the testcase id for current one, if still carries the old one
+    //       let idTokenized = id.split('::');
+    //       let prevTestCaseId = idTokenized[0];
+    //       let prevNodeId = idTokenized[1];
+    //       let prevExecutionId = idTokenized[2];
+
+    //       if (prevTestCaseId !== testcaseid) {
+    //         id = `${testcaseid}::${prevNodeId}::${prevExecutionId}`
+    //       }
+
+    //       // if it has iterate over the executionId (last part of the unique runtime id)
+
+    //       let posExecId = id.lastIndexOf('::');
+    //       let prefixId = id.substr(0, posExecId);
+    //       let executionId = parseInt(id.substr(posExecId + 2));
+
+    //       uniqueExecutionNodeId = `${prefixId}::${executionId}`;
+    //       while (uniqueExecutionNodeId in this._cache) {
+    //         executionId = executionId + 1;
+    //         uniqueExecutionNodeId = `${prefixId}::${executionId}`;
+    //       }
+    //     }
+
+
+    //     return uniqueExecutionNodeId;
+    //   }
+}
+
+
+module.exports = {
+    DebuggerTool
+}

package/src/api/tools/filemanager/index.js

@@ -0,0 +1,127 @@
+const { DesignerTool } = require("../base/DesignerTool");
+
+/**
+ * FileManagerTool
+ * A cloud designer tool responsible to facilitate the sync of files between the frontend and the local filesystem.
+ * This tool will support the following operations: rename, update, add and delete files.
+ *
+ */
+class FileManagerTool extends DesignerTool {
+    constructor(designerServer) {
+        super(designerServer);
+    }
+
+    install() {
+        /**
+         * { "type": "filemanager:pull" }
+         */
+        this.addEventHandler('filemanager:pull', this.executePull('filemanager:pull'));
+        /**
+         * { "type": "filemanager:push",
+         *   "payload": { ... }}
+         */
+        this.addEventHandler('filemanager:push', this.executePush('filemanager:push'));
+    }
+
+    /**
+     * Invoked by the client to get the project structure on the server (localfilesystem).
+     * @param {string} - eventType: "filemanager:pull"
+     */
+    executePull(eventType) {
+        /**
+         * @param {ws} - client websocket
+         * @returns {Object} - response
+         * :: Example
+         * {
+        *  'flow': '/project-directory/simple-flow.json',
+         *  'files': {
+         *      '/project-directory': {
+         *          '.kumologica': {
+         *              'editor.json': <content>
+         *              '.kumologica-ignore: "build \n",
+         *          }
+        *
+         *          'simple-flow.json': <content>,
+         *          'config.json': <content>,
+         *          'package.json': <content>
+         *      }
+         *  }
+        *
+         * }
+        */
+        return async (ws, payload) => {
+            try {
+                const response = this.flowServer.runtime.storage.getProjectStructure();
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, "An error ocurred while pulling project directory from the server");
+            }
+        }
+    }
+
+    /**
+     * Invoked by the client to send the project structure updates into the server.
+     * @param {string} - eventType: "filemanager:push"
+     */
+    executePush(eventType) {
+         /**
+         * @param {ws} - client websocket
+         * @param {Object} payload - request's payload
+         * @param {}
+         * :: Example
+         * {[
+         * {
+         *      operation: "add_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem",
+         *      content: <content>
+         *  },
+         * {
+         *      operation: "delete_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem"
+         *  },
+         * {
+         *      operation: "update_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem",
+         *      content: <content>
+         *  },
+         *  {
+         *      operation: "rename_file",
+         *      path: "/project-directory",
+         *      filename: "secret.pem",
+         *      newFileName: "keys.pem"
+         *  },
+         *  {
+         *      operation: "add_folder",
+         *      path: "/project-directory/new-folder",
+         *  },
+         * {
+         *      operation: "remove_folder",
+         *      path: "/project-directory/old-folder",
+         *  },
+         * {
+         *      operation: "rename_folder",
+         *      path: "/project-directory/old-folder",
+         *      newPath: "/project-directory/new-folder",
+         *  },
+
+         * ]}
+        */
+        return async (ws, payload) => {
+            try {
+                const response = await this.flowServer.runtime.storage.fileOperation(payload);
+                this.sendResponse(ws, eventType, response);
+            } catch (err) {
+                console.log(err);
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+}
+
+module.exports = {
+    FileManagerTool
+}

package/src/api/tools/git/index.js

@@ -0,0 +1,103 @@
+const { DesignerTool } = require("../base/DesignerTool");
+const simpleGit = require('simple-git');
+
+class GitTool extends DesignerTool {
+    constructor(designerServer) {
+        super(designerServer);
+    }
+
+    install() {
+        /**
+         * { "type": "git:status"}
+         */
+        this.addEventHandler('git:status', this.executeGitStatus('git:status'));
+        /**
+         * { "type": "git:add-and-commit",
+         *   "payload": { "commit": "commit message..." }}
+         */
+        this.addEventHandler('git:add-and-commit', this.executeAddAndCommit('git:add-and-commit'));
+        /**
+         * { "type": "git:push-origin" 
+         *   "payload": {
+         *      proxy: "http://my-annoying-proxy" // optional
+         *   }
+         * }
+         */
+        this.addEventHandler('git:push-origin', this.executePushOrigin('git:push-origin'));
+
+    }
+
+    gitCommand(options) {
+        const { proxy } = options || {};
+
+        // base options
+        let gitOptions = {
+            baseDir: this.flowServer.serverSettings.projectDir,
+            binary: 'git',
+            maxConcurrentProcesses: 6,
+            trimmed: false
+        }
+        // proxy included?
+        if (proxy) {
+            gitOptions = { ...gitOptions, config: [`http.proxy=${proxy}`] }
+        }
+        return simpleGit(gitOptions);
+    }
+
+    executeGitStatus(eventType) {
+        return async (ws, payload) => {
+            try {
+                const git = this.gitCommand();
+                let status = await git.status();  //['-', 'sb']  // newStatus = {ahead, behind, current, tracking};
+                this.sendResponse(ws, eventType, { status });
+            } catch (err) {
+                this.sendError(ws, eventType, "The current project directory is not a Git repository. Please initialize Git in this directory.");
+            }
+        }
+    }
+
+    executeAddAndCommit(eventType) {
+        return async (ws, payload) => {
+            try {
+                const { commit } = payload;
+                if (!commit) {
+                    throw new Error('Commit message cannot be empty')
+                }
+                const git = this.gitCommand();
+                const resp = await git.add('./*').commit(commit);
+                this.sendResponse(ws, eventType, { resp });
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+
+    executePushOrigin(eventType) {
+        return async (ws, payload) => {
+            try {
+                const { proxy } = payload;
+                const git = this.gitCommand({ proxy });
+                let currentBranch = await this.readCurrentBranch();
+                const resp = await git.push('origin', currentBranch);
+                this.sendResponse(ws, eventType, { resp });
+            } catch (e) {
+                this.sendError(ws, eventType, err.message);
+            }
+        }
+    }
+
+    async readCurrentBranch() {
+        try {
+            const git = this.gitCommand();
+            const localBranches = await git.branchLocal();
+            return localBranches.current;
+        } catch (err) {
+            throw err;
+        }
+
+    }
+}
+
+module.exports = {
+    GitTool
+}

package/src/api/tools/index.js

@@ -0,0 +1,13 @@
+const { TestTool } = require('./test');
+const { CoreTools } = require('./core');
+const { DebuggerTool } = require('./debugger');
+const { GitTool } = require('./git');
+const { FileManagerTool } = require('./filemanager');
+
+module.exports = {
+    CoreTools,
+    TestTool,
+    DebuggerTool,
+    GitTool,
+    FileManagerTool
+}

package/src/api/tools/test/index.js

@@ -0,0 +1,56 @@
+const { DesignerTool } = require('../base/DesignerTool');
+const { TestCaseRunner, InMemoryReporter } = require('./lib/TestCaseRunner');
+
+
+class TestTool extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        /**
+         * { type: 'test:run',
+         *   payload: { testcaseid: '123432.34343'} }
+         */
+        this.addEventHandler('test:run', this.executeTestRunAction('test:run'));
+        this.addEventHandler('test:findTestCases', this.executeTestFindTestCasesAction('test:findTestCases'));
+    }
+    executeTestRunAction(eventType) {
+        return async (ws, payload) => {
+            const { testcaseid } = payload || {};
+            const reporter = new InMemoryReporter();
+            const runner = new TestCaseRunner(this.flowServer, testcaseid, [reporter]);
+            try {
+                await runner.runAsync();
+
+                let response = {
+                    testCaseExecutionTimeInMs: reporter.executionTimeInMs,
+                    testCaseID: reporter.testCaseID,
+                    testCaseDescription: reporter.testCaseDescription,
+                    assertions: reporter.assertionResults,
+                    flowResponse: reporter.flowResponse
+                }
+                this.sendResponse(ws, eventType, response);
+
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+
+    executeTestFindTestCasesAction(eventType) {
+        return async (ws, payload) => {
+            const flowApp = this.flowServer.nodes.getFlows();
+            let testNodes = []
+            if (flowApp && flowApp.flows && flowApp.flows.length > 0) {
+             testNodes = flowApp.flows.filter((node)=> node.type.toLowerCase() === 'httptestcase' || node.type.toLowerCase() ==='testcase')
+            }
+            this.sendResponse(ws, eventType, testNodes);
+        }
+    }
+}
+
+
+module.exports = {
+    TestTool
+}

package/src/api/tools/test/lib/TestCaseRunner.js

@@ -0,0 +1,105 @@
+const got = require('got');
+const { performance } = require('perf_hooks');
+const { EventEmitter } = require('events').EventEmitter;
+
+const { TerminalReporter, InMemoryReporter } = require('./reporters');
+
+const TESTCASE_SIGNALS = {
+    TESTCASE_STOP: '__testrunner-stop__',
+};
+
+class TestCaseRunner {
+    constructor(flowServer, testCaseId, testReporters) {
+        this.flowServer = flowServer;
+        this.testCaseId = testCaseId;
+        this.testReporters = testReporters;
+
+        // Measuring the execution time
+        this.timeTestCaseStart = null;
+        this.timeTestCaseEnd = null;
+
+        // Managing runtime events
+        this.runtimeEventEmitter = this.flowServer.events;
+
+        // Signal the start/end of testcase execution
+        this.testCaseRunnerEmitter = new EventEmitter();
+
+    }
+
+    subscribeRuntimeEvents() {
+        let runtimeEventTypes = this.flowServer.eventTypes;
+
+        this.runtimeEventEmitter.on('runtime-event', async (data) => {
+            let p = data.payload;
+
+            // Attributes from p.testCaseResults
+            let testCaseID;
+            let testCaseDescription;
+            let target; // flow:*
+            let targetOutput; // { response: {}, error: {}},
+            let assertionResults; // [...]
+            let error;
+
+            switch (data.id) {
+                case runtimeEventTypes.TEST_TESTCASE_START:
+                    this.timeTestCaseStart = performance.now();
+                    ({ testCaseID, testCaseDescription } = p.testCaseResults);
+                    this.testReporters.map(reporter => reporter.handleStart(testCaseID, testCaseDescription));
+                    break;
+                case runtimeEventTypes.TEST_TESTCASE_END:
+                case runtimeEventTypes.TEST_TESTCASE_END_WITH_ERROR:
+                    this.timeTestCaseEnd = performance.now();
+                    ({ testCaseID, testCaseDescription, target, assertionResults, error, targetOutput } = p.testCaseResults); // targetOutput.response: { statusCode, headers, body } }
+                    this.testReporters.map(reporter => reporter.handleResult(testCaseID, testCaseDescription, target, assertionResults, error, this.timeTestCaseStart, this.timeTestCaseEnd, targetOutput));
+                    this.testCaseRunnerEmitter.emit(TESTCASE_SIGNALS.TESTCASE_STOP);
+                    break;
+                default:
+                // do nothing
+            }
+
+        });
+
+    }
+
+    async runAsync() {
+        return new Promise(async (resolve, reject) => {
+            // Subscribe to the runtime events
+            this.subscribeRuntimeEvents();
+            // Wait for the end of the testcase execution
+            this.testCaseRunnerEmitter.on(TESTCASE_SIGNALS.TESTCASE_STOP, () => {
+                resolve();
+            });
+            try {
+                // Trigger the execution of the testcase
+                await this.invokeTest(this.testCaseId);
+            } catch (err) {
+                if (err.response.statusCode === 404 &&
+                    err.response.body === '{"errorMessage":"Targeted node not found"}') {
+                    reject(new Error('TestCaseID not found'));
+                } else {
+                    resolve();
+                }
+            }
+
+        })
+
+    }
+
+    async invokeTest(testCaseId) {
+        let resp = await got({
+            url: `http://127.0.0.1:${this.flowServer.settings.port}`,
+            method: 'POST',
+            headers: { 'x-kumologica-testcasenode': `${testCaseId}` },
+        });
+        return resp;
+    }
+}
+
+
+
+module.exports = {
+    TestCaseRunner,
+    // Reporters
+    TerminalReporter,
+    InMemoryReporter
+}