Merge remote-tracking branch 'upstream/main' into feature/adaptCobiGenTemplates

Author: denise-khuu

buildRun.ps1

@@ -4,4 +4,4 @@ Copy-Item -Force -Recurse -Path $PSScriptRoot\playbooks\ -Destination $PSScriptR
 Copy-Item -Force -Recurse -Path $PSScriptRoot\environments\ -Destination $PSScriptRoot\build
 Copy-Item -Force -Recurse -Path $PSScriptRoot\runners\ -Destination $PSScriptRoot\build
 npm test
-node $PSScriptRoot\build\engine\run.js
+node $PSScriptRoot\build\engine\run.js --skipCommands.console dockerCompose

documentation/Functions.md

@@ -13,6 +13,7 @@ The following functions are already implemented:
 * runServerJava
 * buildNg
 * npmInstall
+* dockerCompose
 * downloadFile
 * nextKatacodaStep
 * adaptCobiGenTemplates
@@ -163,6 +164,20 @@ npmInstall("my-thai-star/angular")
 
 ***
 
+### dockerCompose
+#### parameter 
+1. Path to the directory where the docker-compose.yml file is located, relative to workspace.
+2. Assertion information. Only needed for the console runner to check if the server was started properly.
+#### example 
+dockerCompose("my-thai-star", { "startupTime": 600, "port": 8081, "path": "" })
+
+##### Assertion information
+startupTime = Time in seconds to wait before checking if the server is running
+port: Port on which the server is running
+path: The URL path on which is checked if the server is running
+
+***
+
 ### downloadFile
 #### parameter 
 1. URL of the file to be downloaded.

engine/engine.ts

@@ -24,22 +24,33 @@ export class Engine {
             (await this.getRunner(this.environment.runners[runnerIndex])).init(this.playbook);
         }
 
-        for (let stepIndex in this.playbook.steps) {
+        mainloop: for (let stepIndex in this.playbook.steps) {
             for (let lineIndex in this.playbook.steps[stepIndex].lines) {
+                let foundRunnerToExecuteCommand = false;
                 for (let runnerIndex in this.environment.runners) {
                     let runner = await this.getRunner(this.environment.runners[runnerIndex]);
                     if (runner.supports(this.playbook.steps[stepIndex].lines[lineIndex].name)) {
                         var result = new RunResult();
+                        if(runner.commandIsSkippable(this.playbook.steps[stepIndex].lines[lineIndex].name)) {
+                            console.log("Command " + this.playbook.steps[stepIndex].lines[lineIndex].name + " will be skipped.");
+                            continue;
+                        }
                         try {
                             result = runner.run(this.playbook.steps[stepIndex], this.playbook.steps[stepIndex].lines[lineIndex]);
                         }
                         catch (e) {
                             result.exceptions.push(e);
                         }
+                        
                         await runner.assert(this.playbook.steps[stepIndex], this.playbook.steps[stepIndex].lines[lineIndex], result);
+                        
+                        foundRunnerToExecuteCommand = true;
                         break;
                     }
                 }
+                if(!foundRunnerToExecuteCommand) {
+                    break mainloop;
+                }   
             }
         }
 

engine/run.ts

@@ -77,7 +77,8 @@ class Run {
     traverseArgs(parentName, obj) {
 
         for (let index in obj) {
-            if (isObject(obj[index])) {
+            if (obj[index] instanceof Object) {
+                this.args.set(parentName + index, obj[index]);
                 this.traverseArgs(parentName + index + ".", obj[index]);
             }
             else {

engine/runner.ts

@@ -110,4 +110,15 @@ export abstract class Runner {
         fs.mkdirSync(path, { recursive: true });
         return path;
     }
+
+    commandIsSkippable(command: String): Boolean {
+        let returnVal = false; 
+        let runner = this.getVariable("skipCommands." + this.getRunnerName());
+        if(runner) {
+            if((runner instanceof Array && runner.indexOf(command) != -1) || runner == command) {
+                returnVal = true;
+            }
+        } 
+        return returnVal;
+    }
 }

runners/console/index.ts

@@ -36,6 +36,7 @@ export class Console extends Runner {
         }
         this.setVariable(this.workspaceDirectory, path.join(this.getWorkingDirectory()));
         this.env = process.env;
+       
     }
 
     destroy(playbook: Playbook): void {
@@ -204,6 +205,27 @@ export class Console extends Runner {
         return result;
     }        
 
+
+    runDockerCompose(step: Step, command: Command): RunResult {
+        let result = new RunResult();
+        result.returnCode = 0;
+        
+        let filepath = path.join(this.getVariable(this.workspaceDirectory), command.parameters[0]);
+
+        let process = this.executeCommandAsync("docker-compose up", filepath, result);
+        process.on('close', (code) => {
+            if (code !== 0) {
+                result.returnCode = code;
+            }
+          });
+        if(process.pid && command.parameters.length == 2) {
+            this.asyncProcesses.push({ pid: process.pid, name: "dockerCompose", port: command.parameters[1].port });
+        }
+        
+        return result;
+        
+    }
+
     runRunServerJava(step: Step, command: Command): RunResult {
         let result = new RunResult();
         result.returnCode = 0;
@@ -231,6 +253,7 @@ export class Console extends Runner {
         this.executeCommandSync("git clone " + command.parameters[1], directorypath, result);
 
         return result;
+
     }
 
     runNpmInstall(step: Step, command: Command): RunResult {
@@ -434,7 +457,37 @@ export class Console extends Runner {
             throw error;
         }
     }
-  
+
+    async assertDockerCompose(step: Step, command: Command, result: RunResult) {
+        try {
+            let assert = new Assertions()
+            .noErrorCode(result)
+            .noException(result);
+
+            if(command.parameters.length > 1) {
+                if(!command.parameters[1].startupTime) {
+                    console.warn("No startup time for command dockerCompose has been set")
+                }
+                let startupTimeInSeconds = command.parameters[1].startupTime ? command.parameters[1].startupTime : 0;
+                await this.sleep(command.parameters[1].startupTime);
+
+                if(!command.parameters[1].port) {
+                    this.killAsyncProcesses();
+                    throw new Error("Missing arguments for command dockerCompose. You have to specify a port and a path for the server. For further information read the function documentation.");
+                } else {
+                    let isReachable = await assert.serverIsReachable(command.parameters[1].port, command.parameters[1].path);
+                    if(!isReachable) {
+                        this.killAsyncProcesses();
+                        throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + command.parameters[1].port + "/" + command.parameters[1].path);
+                    }
+                }
+            }
+         } catch(error) {
+            this.cleanUp();
+            throw error;
+        }  
+    }
+
     async assertRunServerJava(step: Step, command: Command, result: RunResult) {
         try {
             let assert = new Assertions()
@@ -683,5 +736,6 @@ export class Console extends Runner {
         }
     }
 
+    
 
-}
+}