Merge pull request #154 from EduardKrieger/executeFile

ExecuteCommand

Author: EduardKrieger

assertions/serverIsReachable.ts

@@ -8,10 +8,8 @@ export class ServerIsReachable {
         let interval = this.getValue(parameters, 'intervall', 5);
         let startupTime = this.getValue(parameters, 'startupTime', 600);
         let command = this.getValue(parameters, 'command', "");
-
         if(!port) {
             throw new Error("Missing arguments for the command " + command + ". You have to specify a port for the server. For further information read the function documentation.");
-
         } else {
             let timeoutFlag = false;
             let reached = false;
@@ -45,4 +43,4 @@ export class ServerIsReachable {
     private static sleep(seconds: number) {
         return new Promise(resolve => setTimeout(resolve, seconds * 1000));
     }
-}
+}

documentation/Functions.md

@@ -4,6 +4,7 @@ The following functions are already implemented:
 * restoreDevonfwIde
 * restoreWorkspace
 * changeWorkspace
+* executeCommand
 * installCobiGen
 * cobiGenJava
 * createDevon4jProject
@@ -114,6 +115,39 @@ will set the workspace directory to "[working directory]/devonfw/workspaces/proj
 
 Learn more about the workspace directory and working directory on [Structure](https://github.com/devonfw-tutorials/tutorial-compiler/wiki/Structure)
 
+### executeCommand
+#### parameter 
+1. The command that will be executed on Windows
+2. The command that will be executed on Linux
+3. Json-object with optional fields
+   * (Optional) Directory where the command will be executed, if not in current directory (relative to workspace){"dir": string}
+   * (Optional) Synchronous or asynchronous process. Use asynchronous when starting a server. Default is synchronous. {"asynchronous": boolean}
+   * (Optional) Array of arguments {"args": string[]}
+4. Assert information needed if you start a server to check server availability. Only required when you start a asynchronous server. 
+
+#### Commands
+It is needed to pass a command for Windows and also for Linux-based systems because both systems will always be tested.
+
+##### 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
+interval: The availability of the server is checked in the given interval
+* (Required) port: will throw error if no port is given.
+* (Optional) path: subpath which should be pinged, i.e: if localhost:8081/jumpthequeue should be checked path should be "jumpthequeue". DEFAULT: ""
+* (Optional) interval: interval in seconds in which the server should be pinged until it is available or timeouted. DEFAULT: 5 seconds
+* (Optional) startupTime: seconds until a timeout will occur and an error will be thrown. DEFAULT: 10 minutes
+
+#### example
+
+executeCommand("node", "node" ,{"args": ["-v"]})
+Will create a command for executing node -v .
+
+executeCommand("somePollingScript.ps1","bash somePollingScript.sh", {"dir": "data/setup","asynchronous": true, "args": ["--params 5"]})
+Will create a command to execute the script in the directory with the parameter --params 5 and in a new terminal.
+
+executeCommand("someServerScript.ps1","bash someServerScript.sh", {"asynchronous": true, "args":["-port 8080"] },{"port":8080 , "startupTime": 20, "path": "some/path/", "interval": 2})
+Starting a server in a new terminal. You have to specify the port for testing, the other parameters are optional. The startupTime can specify how long the runner will wait for a response from the server process and with interval you can set the frequenzy for the server testing. The path is the subpath from your server that should be reached.
 
 
 ### installCobiGen
@@ -193,12 +227,14 @@ example:{...,"placeholder": "private int age;"}
 | --- | --- | --- |
 |<p>private int age;<br><br>public String getFirstname() {<br>return firstname;<br>}<br></p>|<p>private int age;<br><br>private String company;<br>public String getCompany() {<br>return firstname;<br>}<br>public void setCompany(String company) {<br>this.company = company;<br>}</p>|<p>private int age;<br><br>private String company;<br>public String getCompany() {<br>return firstname;<br>}<br>public void setCompany(String company) {<br>this.company = company;<br><br>public String getFirstname() {<br>return firstname;<br>}<br></p>|
 
+
 ##### Prerequisite
 The usage of the line number function requires having VSCode installed on your System. Not having VSCode installed will not create any output for Katacoda.
 
 ##### Name of the placeholder
 If you want to insert content into your code between two existing lines, take the previous line as your placeholder or use the option to insert at a line number. Add your placeholder into the new file or string, otherwise it will be replaced entirely.
 
+
 A placeholder is optional. If you do not define a placeholder, the content in the existing file will be simply replaced by the new content.
 
 Please try not to use custom placeholders. Keep in mind that you might want to build the project before changing them. Custom placeholders with a comment-syntax (e.g. "//PLACEHOLDER") will be removed by the console-environment and others might cause errors.

localBuildRun.ps1

@@ -5,4 +5,7 @@ Copy-Item -Force -Recurse -Path $PSScriptRoot\environments\ -Destination $PSScri
 Copy-Item -Force -Recurse -Path $PSScriptRoot\runners\ -Destination $PSScriptRoot\build
 npm test
 if(-not $?) { throw 'tests failed' } 
-node $PSScriptRoot\build\engine\run.js $args 
+node $PSScriptRoot\build\engine\run.js $args
+if(Test-Path $PSScriptRoot\build\playbooks){
+    Remove-Item .\build\playbooks -Recurse -Force
+}

localBuildRun.sh

@@ -9,4 +9,6 @@ if [ $? -eq 1 ]; then
     exit 1
 fi
 
-node build/engine/run.js $*
+node build/engine/run.js $*
+
+[ -d build/playbooks ] && rm -rf build/playbooks

runners/console/consoleInterfaces.ts

@@ -5,6 +5,5 @@ export enum ConsolePlatform {
 
 export interface AsyncProcess {
     pid: number;
-    name: string;
     port: number;
 }

runners/console/consoleUtils.ts

@@ -25,7 +25,6 @@ export class ConsoleUtils {
 
     static executeCommandAsync(command: string, directory: string, result: RunResult, env: any): child_process.ChildProcess {
         if(result.returnCode != 0) return;
-
         let process = child_process.spawn(command, [], { shell: true, cwd: directory, env: env });
 
         let output = "";
@@ -66,4 +65,4 @@ export class ConsoleUtils {
             fs.renameSync(path.join(homedir, ".devon_backup"), path.join(homedir, ".devon"));
         }
     }
-}
+}

runners/console/index.ts

@@ -8,7 +8,9 @@ import * as path from 'path';
 import * as fs from "fs-extra";
 import * as psList from "ps-list";
 import { ConsoleUtils } from "./consoleUtils";
+
 const findProcess = require("find-process");
+
 const os = require("os");
 
 export class Console extends Runner {
@@ -285,7 +287,7 @@ export class Console extends Runner {
                 }
             });
             if(process.pid) {
-                this.asyncProcesses.push({ pid: process.pid, name: "dockerCompose", port: runCommand.command.parameters[1].port });
+                this.asyncProcesses.push({ pid: process.pid, port: runCommand.command.parameters[1].port });
             }
         }else{
             result.returnCode = 1; 
@@ -306,7 +308,7 @@ export class Console extends Runner {
                 : ConsoleUtils.executeCommandAsync("mvn spring-boot:run", serverDir, result, this.env);
 
                 if(process.pid) {
-                    this.asyncProcesses.push({ pid: process.pid, name: "java", port: runCommand.command.parameters[1].port });
+                    this.asyncProcesses.push({ pid: process.pid, port: runCommand.command.parameters[1].port });
                 }
         }else{
             result.returnCode = 1; 
@@ -374,7 +376,7 @@ export class Console extends Runner {
                 ? ConsoleUtils.executeDevonCommandAsync("ng serve", projectDir, path.join(this.getWorkingDirectory(), "devonfw"), result, this.env)
                 : ConsoleUtils.executeCommandAsync("ng serve", projectDir, result, this.env);
             if(process.pid) { 
-                this.asyncProcesses.push({ pid: process.pid, name: "node", port: runCommand.command.parameters[1].port });
+                this.asyncProcesses.push({ pid: process.pid,port: runCommand.command.parameters[1].port });
             }
         }else{
             result.returnCode = 1; 
@@ -439,7 +441,7 @@ export class Console extends Runner {
 
         return result;
     }
-
+  
     runChangeWorkspace(runCommand: RunCommand): RunResult {
         let result = new RunResult();
         result.returnCode = 0;
@@ -448,10 +450,70 @@ export class Console extends Runner {
         if(!fs.existsSync(workspacesDir))
             fs.mkdirSync(workspacesDir);
         this.setVariable(this.workspaceDirectory, workspacesDir);
+     
+      return result;
+    }
 
-        return result;
+    runExecuteCommand(runCommand: RunCommand): RunResult {
+        let result = new RunResult();
+        result.returnCode = 0; 
+        let commandIndex;
+        if(runCommand.command.parameters[0] && runCommand.command.parameters[1]){
+            commandIndex = this.platform == ConsolePlatform.LINUX ? 1 : 0;
+        }
+        else{
+            throw new Error("You have to pass a command for Windows and Linux based OS");
+        }
+
+        let exeCommand = (runCommand.command.parameters.length > 1 && runCommand.command.parameters[2].args)
+            ? runCommand.command.parameters[commandIndex]+ " " +runCommand.command.parameters[2].args.join(" ")
+            : runCommand.command.parameters[commandIndex];
+
+        let dirPath = (runCommand.command.parameters.length > 1 && runCommand.command.parameters[2].dir)
+            ? path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[2].dir)
+            : this.getVariable(this.workspaceDirectory)
+
+        if(runCommand.command.parameters.length > 2 && runCommand.command.parameters[2].asynchronous){
+            if(runCommand.command.parameters[3].port){
+                let process = ConsoleUtils.executeCommandAsync(exeCommand, dirPath, result,this.env);
+                if(process.pid) {
+                    this.asyncProcesses.push({ pid: process.pid, port: runCommand.command.parameters[3].port});
+                }
+            }
+            else{
+                throw new Error("Missing arguments for the command " + exeCommand + ". You have to specify a port for the server. For further information read the function documentation.");
+            } 
+        }
+        else ConsoleUtils.executeCommandSync(exeCommand, dirPath, result, this.env);
+        
+      return result;
     }
 
+
+    async assertExecuteCommand(runCommand: RunCommand, result: RunResult){
+        try{
+            let assert = new Assertions()
+            .noErrorCode(result)
+            .noException(result);
+            if(runCommand.command.parameters.length > 3 && runCommand.command.parameters[2].asynchronous){
+                await assert.serverIsReachable({
+                    path: runCommand.command.parameters[3].path,
+                    port: runCommand.command.parameters[3].port,
+                    interval: runCommand.command.parameters[3].interval,
+                    startupTime: runCommand.command.parameters[3].startupTime,
+                    command: this.platform == ConsolePlatform.WINDOWS 
+                        ? runCommand.command.parameters[0] 
+                        : runCommand.command.parameters[1] 
+                });
+            }
+        } catch(error) {
+            await this.cleanUp();
+            throw error;
+        }
+
+    }
+
+
     runAddSetupScript(runCommand: RunCommand): RunResult {
         let result = new RunResult();
         result.returnCode = 0;
@@ -464,14 +526,15 @@ export class Console extends Runner {
 
         return result;
     }
-
+  
     runOpenFile(runCommand: RunCommand): RunResult {
         let result = new RunResult();
         result.returnCode = 0;
         //Only needed for katacoda, wiki runner and the assertions
         return result;
     }
 
+
     async assertInstallDevonfwIde(runCommand: RunCommand, result: RunResult) {
         try {
             let installedTools = runCommand.command.parameters[0];
@@ -851,6 +914,7 @@ export class Console extends Runner {
                 return process.ppid == processIdToKill;
             });
 
+
             if(childProcesses.length > 0) {
                 for(let childProcess of childProcesses) {
                     killProcessesRecursively(processes, childProcess.pid)
@@ -869,24 +933,21 @@ export class Console extends Runner {
             for(let asyncProcess of this.asyncProcesses) {
                 killProcessesRecursively(processes, asyncProcess.pid);
             }
-            
             //Check if there are still running processes on the given ports
-            for(let asyncProcess of this.asyncProcesses) {
+            for(let asyncProcess of this.asyncProcesses.reverse()) {
                 let processes: any[] = await findProcess("port", asyncProcess.port);
                 if(processes.length > 0) {
                     for(let proc of processes) {
-                        if(proc.name == asyncProcess.name || proc.name == asyncProcess.name + ".exe") {
-                            try {
-                                process.kill(proc.pid);
+                        try {
+                            process.kill(proc.pid);
                             } catch(e) {
                                 console.error("Error killing id " + proc.pid, e);
                             }
                         }
                     }
-                }
-            }   
+                }      
+            }
         }
-    }
 
     private async cleanUp(): Promise<void> {
         await this.killAsyncProcesses();

runners/katacoda/index.ts

@@ -400,6 +400,35 @@ export class Katacoda extends Runner {
         return null;
     }
 
+    runExecuteCommand(runCommand: RunCommand) : RunResult {
+        let terminal = (runCommand.command.parameters.length > 2 && runCommand.command.parameters[2].asynchronous) 
+            ? this.getTerminal("executeCommand"+runCommand.stepIndex) 
+            : undefined;
+        
+        let filepath;
+        let changeDir = false;
+        if(runCommand.command.parameters.length > 2 && runCommand.command.parameters[2].dir){
+            filepath = runCommand.command.parameters[2].asynchronous 
+                ? path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[2].dir).replace(/\\/g, "/")
+                : runCommand.command.parameters[2].dir;
+            changeDir = true;
+            this.currentDir = filepath;
+        }
+
+        let bashCommand = {
+            "name" : runCommand.command.parameters[1],
+            "changeDir" : changeDir,
+            "path" : filepath, 
+            "terminalId" : terminal ? terminal.terminalId : 1,
+            "interrupt" : terminal ?  terminal.isRunning : false,
+            "args": (runCommand.command.parameters.length > 2 && runCommand.command.parameters[2].args) ? runCommand.command.parameters[1].args.join(" ") : undefined
+        }
+
+        this.pushStep(runCommand, "Executing the command "+ runCommand.command.parameters[1] , "step"+ runCommand.stepIndex + ".md");
+        this.renderTemplate("executeCommand.md", this.outputPathTutorial + "step" + (runCommand.stepIndex) + ".md", { text: runCommand.text, textAfter: runCommand.textAfter, bashCommand: bashCommand});
+        return null;
+    }
+  
     runChangeWorkspace(runCommand: RunCommand): RunResult {
         let workspacesDir = path.join('/root', runCommand.command.parameters[0]); 
         this.setVariable(this.workspaceDirectory, workspacesDir);
@@ -419,6 +448,7 @@ export class Katacoda extends Runner {
 
         this.pushStep(runCommand);
         return null;
+
     }
 
     runOpenFile(runCommand: RunCommand): RunResult {
@@ -489,7 +519,7 @@ export class Katacoda extends Runner {
             this.currentStepIndex++; 
         }
     }
-
+    
     supports(name: string, parameters: any[]): boolean {
         if(name == "changeFile" && parameters[1].lineNumber){
             if(this.showVsCodeIde){
@@ -505,3 +535,4 @@ export class Katacoda extends Runner {
     }
 
 }
+

runners/katacoda/templates/executeCommand.md

@@ -0,0 +1,13 @@
+<%= text; %>
+
+<% if(bashCommand.interrupt){%><% if(bashCommand.changeDir){%>We want to execute the command in a different directory so you have to change your current directory. Some command is already running in terminal <%= bashCommand.terminalId; %> to stop the execution just use this command 
+`cd <%= bashCommand.path; %> `{{execute T<%= bashCommand.terminalId; %> interrupt}} <% }} else{%>
+<% if(bashCommand.changeDir){%>We want to execute the command in a different directory so you have to change your current directory.
+With the next command we also open a new terminal, so you have to execute the command twice 
+`cd <%= bashCommand.path; %> `{{execute T<%= bashCommand.terminalId; %>}}. <% } %><% } %>
+
+<% if(bashCommand.interrupt){ %><% if(bashCommand.changeDir){%>Run <%= bashCommand.name; %> with this bash-command.`<%= bashCommand.name; %> <%= bashCommand.args; %>`{{execute T<%= bashCommand.terminalId; %>}} <% } else{%> Some command is already running in terminal <%= bashCommand.terminalId; %>. Rerun the command to stop and relaunch it automatically. `<%= bashCommand.name; %> <%= bashCommand.args; %>`{{execute T<%= bashCommand.terminalId; %> interrupt }} <%} }else{ %>Run <%= bashCommand.name; %> with this bash-command.
+`<%= bashCommand.name; %> <%= bashCommand.args; %>`{{execute T<%= bashCommand.terminalId; %>}} <%} %>
+
+<%= textAfter; %>
+

runners/wikiConsole/index.ts

@@ -102,6 +102,7 @@ export class WikiConsole extends WikiRunner {
         return null;
     }
 
+
     runDockerCompose(runCommand: RunCommand): RunResult {
         let dir = runCommand.command.parameters[0];
         this.renderWiki(path.join(this.getRunnerDirectory(), "templates", "dockerCompose.asciidoc"), { dir: dir, port: runCommand.command.parameters[1].port, app_path: runCommand.command.parameters[1].path })