Merge pull request devonfw-tutorials#155 from GuentherJulian/fix/cleanUp

GuentherJulian · web-flow · commit 2bc1e0cdac43 · 2021-03-23T08:19:47.000+01:00
fix cleanup in console runner
diff --git a/engine/engine.ts b/engine/engine.ts
@@ -57,7 +57,7 @@ export class Engine {
         }
 
         for (let runnerIndex in this.environment.runners) {
-            (await this.getRunner(this.environment.runners[runnerIndex])).destroy(this.playbook);
+            await (await this.getRunner(this.environment.runners[runnerIndex])).destroy(this.playbook);
         }
     }
 
diff --git a/engine/runner.ts b/engine/runner.ts
@@ -97,14 +97,17 @@ export abstract class Runner {
         }
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
     }
 
-    protected createFolder(path: string, deleteFolerIfExist: boolean) {
+    protected createFolder(path: string, deleteFolderIfExist: boolean) {
         if(fs.existsSync(path)) {
-            if(deleteFolerIfExist) {
-                rimraf.sync(path);
-                fs.mkdirSync(path, { recursive: true });
+            if(deleteFolderIfExist) {
+                try {
+                    rimraf.sync(path);
+                } catch(e) {
+                    console.log("Error deleting foler " + path, e);
+                }
             } else return path;
         }
         fs.mkdirSync(path, { recursive: true });
diff --git a/engine/wikiRunner.ts b/engine/wikiRunner.ts
@@ -13,7 +13,7 @@ export abstract class WikiRunner extends Runner {
         this.outputPathTutorial = this.createFolder(path.join(outputDirectory, playbook.name), true);
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
 
     }
 
diff --git a/runners/console/index.ts b/runners/console/index.ts
@@ -36,8 +36,8 @@ export class Console extends Runner {
         this.env = process.env;
     }
 
-    destroy(playbook: Playbook): void {
-        this.cleanUp();
+    async destroy(playbook: Playbook): Promise<void> {
+        await this.cleanUp();
     }
 
     runInstallDevonfwIde(runCommand: RunCommand): RunResult {
@@ -361,7 +361,7 @@ export class Console extends Runner {
                 assert.directoryExits(path.join(this.getWorkingDirectory(), "devonfw", "software", tool));
             }
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -379,7 +379,7 @@ export class Console extends Runner {
             .fileExits(path.join(this.getWorkingDirectory(), "devonfw", "software", "cobigen-cli", "cobigen.jar"))
             .fileExits(path.join(this.getWorkingDirectory(), "devonfw", "software", "cobigen-cli", "cobigen"));
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -393,7 +393,7 @@ export class Console extends Runner {
             .directoryExits(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0], "core", "target"))
             .directoryExits(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0], "server", "target"));
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -405,7 +405,7 @@ export class Console extends Runner {
             .noException(result)
             .fileExits(path.join(this.getWorkingDirectory(), "devonfw", "workspaces", "main", runCommand.command.parameters[0]));
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -423,7 +423,7 @@ export class Console extends Runner {
             .directoryExits(path.join(workspaceDir, runCommand.command.parameters[0], "server", "src", "main", "java"))
             .fileExits(path.join(workspaceDir, runCommand.command.parameters[0], "core", "src", "main", "java", "com", "example", "application", runCommand.command.parameters[0], "SpringBootApp.java"));
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -435,7 +435,7 @@ export class Console extends Runner {
             .noException(result)
             .fileExits(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0]));
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -456,7 +456,7 @@ export class Console extends Runner {
             .fileExits(filepath)
             .fileContains(filepath, content);
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -475,18 +475,18 @@ export class Console extends Runner {
                 await this.sleep(runCommand.command.parameters[1].startupTime);
 
                 if(!runCommand.command.parameters[1].port) {
-                    this.killAsyncProcesses();
+                    await 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(runCommand.command.parameters[1].port, runCommand.command.parameters[1].path);
                     if(!isReachable) {
-                        this.killAsyncProcesses();
+                        await this.killAsyncProcesses();
                         throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + runCommand.command.parameters[1].port + "/" + runCommand.command.parameters[1].path);
                     }
                 }
             }
          } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }  
     }
@@ -505,18 +505,18 @@ export class Console extends Runner {
                 await this.sleep(runCommand.command.parameters[1].startupTime);
 
                 if(!runCommand.command.parameters[1].port || !runCommand.command.parameters[1].path) {
-                    this.killAsyncProcesses();
+                    await this.killAsyncProcesses();
                     throw new Error("Missing arguments for command runServerJava. 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(runCommand.command.parameters[1].port, runCommand.command.parameters[1].path);
                     if(!isReachable) {
-                        this.killAsyncProcesses();
+                        await this.killAsyncProcesses();
                         throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + runCommand.command.parameters[1].port + "/" + runCommand.command.parameters[1].path)
                     }
                 }
             }
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -534,7 +534,7 @@ export class Console extends Runner {
             .directoryNotEmpty(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0], repoName))
             .repositoryIsClean(directorypath);
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -552,7 +552,7 @@ export class Console extends Runner {
                 .directoryNotEmpty(path.join(projectDir, "node_modules"));
             }
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -570,7 +570,7 @@ export class Console extends Runner {
             .directoryNotEmpty(directory)
             .fileExits(path.join(directory, runCommand.command.parameters[1]));
          } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -589,18 +589,18 @@ export class Console extends Runner {
                 await this.sleep(runCommand.command.parameters[1].startupTime);
 
                 if(!runCommand.command.parameters[1].port) {
-                    this.killAsyncProcesses();
+                    await this.killAsyncProcesses();
                     throw new Error("Missing arguments for command runClientNg. You have to specify a port for the server. For further information read the function documentation.");
                 } else {
                     let isReachable = await assert.serverIsReachable(runCommand.command.parameters[1].port, runCommand.command.parameters[1].path);
                     if(!isReachable) {
-                        this.killAsyncProcesses();
+                        await this.killAsyncProcesses();
                         throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + runCommand.command.parameters[1].port + "/" + runCommand.command.parameters[1].path)
                     }
                 }
             }
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -625,7 +625,7 @@ export class Console extends Runner {
             .directoryNotEmpty(path.join(projectPath, outputpath));
 
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -638,7 +638,7 @@ export class Console extends Runner {
             .noException(result)
             .directoryExits(folderPath);
          } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -653,7 +653,7 @@ export class Console extends Runner {
             .directoryNotEmpty(templatesDir);
 
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -667,7 +667,7 @@ export class Console extends Runner {
             .directoryExits(projectDir)
             .directoryNotEmpty(projectDir);
         } catch(error) {
-            this.cleanUp();
+            await this.cleanUp();
             throw error;
         }
     }
@@ -690,46 +690,51 @@ export class Console extends Runner {
         return new Promise(resolve => setTimeout(resolve, seconds * 1000));
     }
 
-    private killAsyncProcesses() {
-        if(this.asyncProcesses.length > 0) {
-            psList().then(processes => {
-                // Get all processes and check if they are child orprocesses of the processes that should be terminated. If so, kill them first.
-                let killProcessesRecursively = function(processes, processIdToKill) {
-                    let childProcesses = processes.filter(process => {
-                        return process.ppid == processIdToKill;
-                    });
-
-                    if(childProcesses.length > 0) {
-                        childProcesses.forEach(childProcess => {
-                            killProcessesRecursively(processes, childProcess.pid)
-                        });
-                    }
+    private async killAsyncProcesses(): Promise<void> {
+        let killProcessesRecursively = function(processes: psList.ProcessDescriptor[], processIdToKill: number) {
+            let childProcesses = processes.filter(process => {
+                return process.ppid == processIdToKill;
+            });
 
-                    process.kill(processIdToKill);
+            if(childProcesses.length > 0) {
+                for(let childProcess of childProcesses) {
+                    killProcessesRecursively(processes, childProcess.pid)
                 }
+            }
+
+            try {
+                process.kill(processIdToKill);
+            } catch(e) {
+                console.error("Error killing id " + processIdToKill, e);
+            }
+        }
 
-                this.asyncProcesses.forEach(asyncProcess => {
-                    killProcessesRecursively(processes, asyncProcess.pid);
-                });
-            }).then(() => {
-                //Check if there are still running processes on the given ports
-                this.asyncProcesses.forEach(asyncProcess => {
-                    findProcess("port", asyncProcess.port).then((processes) => {
-                        if(processes.length > 0) {
-                            processes.forEach(proc => {
-                                if(proc.name == asyncProcess.name || proc.name == asyncProcess.name + ".exe") {
-                                    process.kill(proc.pid);
-                                }
-                            });
+        if(this.asyncProcesses.length > 0) {
+            let processes: psList.ProcessDescriptor[] = Array.from((await psList()).values());
+            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) {
+                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);
+                            } catch(e) {
+                                console.error("Error killing id " + proc.pid, e);
+                            }
                         }
-                    })
-                });
-            })
+                    }
+                }
+            }   
         }
     }
 
-    private cleanUp(): void {
-        this.killAsyncProcesses();
+    private async cleanUp(): Promise<void> {
+        await this.killAsyncProcesses();
         ConsoleUtils.restoreDevonDirectory();
     }
 }
diff --git a/runners/katacoda/index.ts b/runners/katacoda/index.ts
@@ -51,7 +51,7 @@ export class Katacoda extends Runner {
         this.assetManager = new KatacodaAssetManager(path.join(this.outputPathTutorial, "assets"));
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
         let tutorialDirectoryName = path.basename(playbook.path);
         this.renderTemplate("intro.md", path.join(this.outputPathTutorial, "intro.md"), { description: playbook.description, tutorialPath: tutorialDirectoryName });
         fs.writeFileSync(this.outputPathTutorial + 'finish.md', "");
diff --git a/runners/vscode/index.ts b/runners/vscode/index.ts
@@ -33,7 +33,7 @@ export class VsCode extends Runner {
         });
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
         this.cleanUp();
     }
 
diff --git a/runners/wikiConsole/index.ts b/runners/wikiConsole/index.ts
@@ -10,7 +10,7 @@ export class WikiConsole extends WikiRunner {
         super.init(playbook);
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
         super.destroy(playbook);
     }
 
diff --git a/runners/wikiEclipse/index.ts b/runners/wikiEclipse/index.ts
@@ -7,7 +7,7 @@ export class WikiEclipse extends WikiRunner {
         super.init(playbook);
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
         super.destroy(playbook);
     }
 }
diff --git a/runners/wikiEditor/index.ts b/runners/wikiEditor/index.ts
@@ -7,7 +7,7 @@ export class WikiEditor extends WikiRunner {
         super.init(playbook);
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
         super.destroy(playbook);
     }
 }
diff --git a/runners/wikiVsCode/index.ts b/runners/wikiVsCode/index.ts
@@ -7,7 +7,7 @@ export class WikiVsCode extends WikiRunner {
         super.init(playbook);
     }
 
-    destroy(playbook: Playbook): void {
+    async destroy(playbook: Playbook): Promise<void> {
         super.destroy(playbook);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ export class Engine {`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`for (let runnerIndex in this.environment.runners) {`
`60`		`- (await this.getRunner(this.environment.runners[runnerIndex])).destroy(this.playbook);`
	`60`	`+ await (await this.getRunner(this.environment.runners[runnerIndex])).destroy(this.playbook);`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -97,14 +97,17 @@ export abstract class Runner {`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`100`		`- destroy(playbook: Playbook): void {`
	`100`	`+ async destroy(playbook: Playbook): Promise<void> {`
`101`	`101`	`}`
`102`	`102`
`103`		`- protected createFolder(path: string, deleteFolerIfExist: boolean) {`
	`103`	`+ protected createFolder(path: string, deleteFolderIfExist: boolean) {`
`104`	`104`	`if(fs.existsSync(path)) {`
`105`		`- if(deleteFolerIfExist) {`
`106`		`- rimraf.sync(path);`
`107`		`- fs.mkdirSync(path, { recursive: true });`
	`105`	`+ if(deleteFolderIfExist) {`
	`106`	`+ try {`
	`107`	`+ rimraf.sync(path);`
	`108`	`+ } catch(e) {`
	`109`	`+ console.log("Error deleting foler " + path, e);`
	`110`	`+ }`
`108`	`111`	`} else return path;`
`109`	`112`	`}`
`110`	`113`	`fs.mkdirSync(path, { recursive: true });`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ export abstract class WikiRunner extends Runner {`
`13`	`13`	`this.outputPathTutorial = this.createFolder(path.join(outputDirectory, playbook.name), true);`
`14`	`14`	`}`
`15`	`15`
`16`		`- destroy(playbook: Playbook): void {`
	`16`	`+ async destroy(playbook: Playbook): Promise<void> {`
`17`	`17`
`18`	`18`	`}`
`19`	`19`
Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@ export class Console extends Runner {`
`36`	`36`	`this.env = process.env;`
`37`	`37`	`}`
`38`	`38`
`39`		`- destroy(playbook: Playbook): void {`
`40`		`- this.cleanUp();`
	`39`	`+ async destroy(playbook: Playbook): Promise<void> {`
	`40`	`+ await this.cleanUp();`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`runInstallDevonfwIde(runCommand: RunCommand): RunResult {`
`@@ -361,7 +361,7 @@ export class Console extends Runner {`
`361`	`361`	`assert.directoryExits(path.join(this.getWorkingDirectory(), "devonfw", "software", tool));`
`362`	`362`	`}`
`363`	`363`	`} catch(error) {`
`364`		`- this.cleanUp();`
	`364`	`+ await this.cleanUp();`
`365`	`365`	`throw error;`
`366`	`366`	`}`
`367`	`367`	`}`
`@@ -379,7 +379,7 @@ export class Console extends Runner {`
`379`	`379`	`.fileExits(path.join(this.getWorkingDirectory(), "devonfw", "software", "cobigen-cli", "cobigen.jar"))`
`380`	`380`	`.fileExits(path.join(this.getWorkingDirectory(), "devonfw", "software", "cobigen-cli", "cobigen"));`
`381`	`381`	`} catch(error) {`
`382`		`- this.cleanUp();`
	`382`	`+ await this.cleanUp();`
`383`	`383`	`throw error;`
`384`	`384`	`}`
`385`	`385`	`}`
`@@ -393,7 +393,7 @@ export class Console extends Runner {`
`393`	`393`	`.directoryExits(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0], "core", "target"))`
`394`	`394`	`.directoryExits(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0], "server", "target"));`
`395`	`395`	`} catch(error) {`
`396`		`- this.cleanUp();`
	`396`	`+ await this.cleanUp();`
`397`	`397`	`throw error;`
`398`	`398`	`}`
`399`	`399`	`}`
`@@ -405,7 +405,7 @@ export class Console extends Runner {`
`405`	`405`	`.noException(result)`
`406`	`406`	`.fileExits(path.join(this.getWorkingDirectory(), "devonfw", "workspaces", "main", runCommand.command.parameters[0]));`
`407`	`407`	`} catch(error) {`
`408`		`- this.cleanUp();`
	`408`	`+ await this.cleanUp();`
`409`	`409`	`throw error;`
`410`	`410`	`}`
`411`	`411`	`}`
`@@ -423,7 +423,7 @@ export class Console extends Runner {`
`423`	`423`	`.directoryExits(path.join(workspaceDir, runCommand.command.parameters[0], "server", "src", "main", "java"))`
`424`	`424`	`.fileExits(path.join(workspaceDir, runCommand.command.parameters[0], "core", "src", "main", "java", "com", "example", "application", runCommand.command.parameters[0], "SpringBootApp.java"));`
`425`	`425`	`} catch(error) {`
`426`		`- this.cleanUp();`
	`426`	`+ await this.cleanUp();`
`427`	`427`	`throw error;`
`428`	`428`	`}`
`429`	`429`	`}`
`@@ -435,7 +435,7 @@ export class Console extends Runner {`
`435`	`435`	`.noException(result)`
`436`	`436`	`.fileExits(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0]));`
`437`	`437`	`} catch(error) {`
`438`		`- this.cleanUp();`
	`438`	`+ await this.cleanUp();`
`439`	`439`	`throw error;`
`440`	`440`	`}`
`441`	`441`	`}`
`@@ -456,7 +456,7 @@ export class Console extends Runner {`
`456`	`456`	`.fileExits(filepath)`
`457`	`457`	`.fileContains(filepath, content);`
`458`	`458`	`} catch(error) {`
`459`		`- this.cleanUp();`
	`459`	`+ await this.cleanUp();`
`460`	`460`	`throw error;`
`461`	`461`	`}`
`462`	`462`	`}`
`@@ -475,18 +475,18 @@ export class Console extends Runner {`
`475`	`475`	`await this.sleep(runCommand.command.parameters[1].startupTime);`
`476`	`476`
`477`	`477`	`if(!runCommand.command.parameters[1].port) {`
`478`		`- this.killAsyncProcesses();`
	`478`	`+ await this.killAsyncProcesses();`
`479`	`479`	`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.");`
`480`	`480`	`} else {`
`481`	`481`	`let isReachable = await assert.serverIsReachable(runCommand.command.parameters[1].port, runCommand.command.parameters[1].path);`
`482`	`482`	`if(!isReachable) {`
`483`		`- this.killAsyncProcesses();`
	`483`	`+ await this.killAsyncProcesses();`
`484`	`484`	`throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + runCommand.command.parameters[1].port + "/" + runCommand.command.parameters[1].path);`
`485`	`485`	`}`
`486`	`486`	`}`
`487`	`487`	`}`
`488`	`488`	`} catch(error) {`
`489`		`- this.cleanUp();`
	`489`	`+ await this.cleanUp();`
`490`	`490`	`throw error;`
`491`	`491`	`}`
`492`	`492`	`}`
`@@ -505,18 +505,18 @@ export class Console extends Runner {`
`505`	`505`	`await this.sleep(runCommand.command.parameters[1].startupTime);`
`506`	`506`
`507`	`507`	`if(!runCommand.command.parameters[1].port \|\| !runCommand.command.parameters[1].path) {`
`508`		`- this.killAsyncProcesses();`
	`508`	`+ await this.killAsyncProcesses();`
`509`	`509`	`throw new Error("Missing arguments for command runServerJava. You have to specify a port and a path for the server. For further information read the function documentation.");`
`510`	`510`	`} else {`
`511`	`511`	`let isReachable = await assert.serverIsReachable(runCommand.command.parameters[1].port, runCommand.command.parameters[1].path);`
`512`	`512`	`if(!isReachable) {`
`513`		`- this.killAsyncProcesses();`
	`513`	`+ await this.killAsyncProcesses();`
`514`	`514`	`throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + runCommand.command.parameters[1].port + "/" + runCommand.command.parameters[1].path)`
`515`	`515`	`}`
`516`	`516`	`}`
`517`	`517`	`}`
`518`	`518`	`} catch(error) {`
`519`		`- this.cleanUp();`
	`519`	`+ await this.cleanUp();`
`520`	`520`	`throw error;`
`521`	`521`	`}`
`522`	`522`	`}`
`@@ -534,7 +534,7 @@ export class Console extends Runner {`
`534`	`534`	`.directoryNotEmpty(path.join(this.getVariable(this.workspaceDirectory), runCommand.command.parameters[0], repoName))`
`535`	`535`	`.repositoryIsClean(directorypath);`
`536`	`536`	`} catch(error) {`
`537`		`- this.cleanUp();`
	`537`	`+ await this.cleanUp();`
`538`	`538`	`throw error;`
`539`	`539`	`}`
`540`	`540`	`}`
`@@ -552,7 +552,7 @@ export class Console extends Runner {`
`552`	`552`	`.directoryNotEmpty(path.join(projectDir, "node_modules"));`
`553`	`553`	`}`
`554`	`554`	`} catch(error) {`
`555`		`- this.cleanUp();`
	`555`	`+ await this.cleanUp();`
`556`	`556`	`throw error;`
`557`	`557`	`}`
`558`	`558`	`}`
`@@ -570,7 +570,7 @@ export class Console extends Runner {`
`570`	`570`	`.directoryNotEmpty(directory)`
`571`	`571`	`.fileExits(path.join(directory, runCommand.command.parameters[1]));`
`572`	`572`	`} catch(error) {`
`573`		`- this.cleanUp();`
	`573`	`+ await this.cleanUp();`
`574`	`574`	`throw error;`
`575`	`575`	`}`
`576`	`576`	`}`
`@@ -589,18 +589,18 @@ export class Console extends Runner {`
`589`	`589`	`await this.sleep(runCommand.command.parameters[1].startupTime);`
`590`	`590`
`591`	`591`	`if(!runCommand.command.parameters[1].port) {`
`592`		`- this.killAsyncProcesses();`
	`592`	`+ await this.killAsyncProcesses();`
`593`	`593`	`throw new Error("Missing arguments for command runClientNg. You have to specify a port for the server. For further information read the function documentation.");`
`594`	`594`	`} else {`
`595`	`595`	`let isReachable = await assert.serverIsReachable(runCommand.command.parameters[1].port, runCommand.command.parameters[1].path);`
`596`	`596`	`if(!isReachable) {`
`597`		`- this.killAsyncProcesses();`
	`597`	`+ await this.killAsyncProcesses();`
`598`	`598`	`throw new Error("The server has not become reachable in " + startupTimeInSeconds + " seconds: " + "http://localhost:" + runCommand.command.parameters[1].port + "/" + runCommand.command.parameters[1].path)`
`599`	`599`	`}`
`600`	`600`	`}`
`601`	`601`	`}`
`602`	`602`	`} catch(error) {`
`603`		`- this.cleanUp();`
	`603`	`+ await this.cleanUp();`
`604`	`604`	`throw error;`
`605`	`605`	`}`
`606`	`606`	`}`
`@@ -625,7 +625,7 @@ export class Console extends Runner {`
`625`	`625`	`.directoryNotEmpty(path.join(projectPath, outputpath));`
`626`	`626`
`627`	`627`	`} catch(error) {`
`628`		`- this.cleanUp();`
	`628`	`+ await this.cleanUp();`
`629`	`629`	`throw error;`
`630`	`630`	`}`
`631`	`631`	`}`
`@@ -638,7 +638,7 @@ export class Console extends Runner {`
`638`	`638`	`.noException(result)`
`639`	`639`	`.directoryExits(folderPath);`
`640`	`640`	`} catch(error) {`
`641`		`- this.cleanUp();`
	`641`	`+ await this.cleanUp();`
`642`	`642`	`throw error;`
`643`	`643`	`}`
`644`	`644`	`}`
`@@ -653,7 +653,7 @@ export class Console extends Runner {`
`653`	`653`	`.directoryNotEmpty(templatesDir);`
`654`	`654`
`655`	`655`	`} catch(error) {`
`656`		`- this.cleanUp();`
	`656`	`+ await this.cleanUp();`
`657`	`657`	`throw error;`
`658`	`658`	`}`
`659`	`659`	`}`
`@@ -667,7 +667,7 @@ export class Console extends Runner {`
`667`	`667`	`.directoryExits(projectDir)`
`668`	`668`	`.directoryNotEmpty(projectDir);`
`669`	`669`	`} catch(error) {`
`670`		`- this.cleanUp();`
	`670`	`+ await this.cleanUp();`
`671`	`671`	`throw error;`
`672`	`672`	`}`
`673`	`673`	`}`
`@@ -690,46 +690,51 @@ export class Console extends Runner {`
`690`	`690`	`return new Promise(resolve => setTimeout(resolve, seconds * 1000));`
`691`	`691`	`}`
`692`	`692`
`693`		`- private killAsyncProcesses() {`
`694`		`- if(this.asyncProcesses.length > 0) {`
`695`		`- psList().then(processes => {`
`696`		`- // Get all processes and check if they are child orprocesses of the processes that should be terminated. If so, kill them first.`
`697`		`- let killProcessesRecursively = function(processes, processIdToKill) {`
`698`		`- let childProcesses = processes.filter(process => {`
`699`		`- return process.ppid == processIdToKill;`
`700`		`- });`
`701`		`-`
`702`		`- if(childProcesses.length > 0) {`
`703`		`- childProcesses.forEach(childProcess => {`
`704`		`- killProcessesRecursively(processes, childProcess.pid)`
`705`		`- });`
`706`		`- }`
	`693`	`+ private async killAsyncProcesses(): Promise<void> {`
	`694`	`+ let killProcessesRecursively = function(processes: psList.ProcessDescriptor[], processIdToKill: number) {`
	`695`	`+ let childProcesses = processes.filter(process => {`
	`696`	`+ return process.ppid == processIdToKill;`
	`697`	`+ });`
`707`	`698`
`708`		`- process.kill(processIdToKill);`
	`699`	`+ if(childProcesses.length > 0) {`
	`700`	`+ for(let childProcess of childProcesses) {`
	`701`	`+ killProcessesRecursively(processes, childProcess.pid)`
`709`	`702`	`}`
	`703`	`+ }`
	`704`	`+`
	`705`	`+ try {`
	`706`	`+ process.kill(processIdToKill);`
	`707`	`+ } catch(e) {`
	`708`	`+ console.error("Error killing id " + processIdToKill, e);`
	`709`	`+ }`
	`710`	`+ }`
`710`	`711`
`711`		`- this.asyncProcesses.forEach(asyncProcess => {`
`712`		`- killProcessesRecursively(processes, asyncProcess.pid);`
`713`		`- });`
`714`		`- }).then(() => {`
`715`		`- //Check if there are still running processes on the given ports`
`716`		`- this.asyncProcesses.forEach(asyncProcess => {`
`717`		`- findProcess("port", asyncProcess.port).then((processes) => {`
`718`		`- if(processes.length > 0) {`
`719`		`- processes.forEach(proc => {`
`720`		`- if(proc.name == asyncProcess.name \|\| proc.name == asyncProcess.name + ".exe") {`
`721`		`- process.kill(proc.pid);`
`722`		`- }`
`723`		`- });`
	`712`	`+ if(this.asyncProcesses.length > 0) {`
	`713`	`+ let processes: psList.ProcessDescriptor[] = Array.from((await psList()).values());`
	`714`	`+ for(let asyncProcess of this.asyncProcesses) {`
	`715`	`+ killProcessesRecursively(processes, asyncProcess.pid);`
	`716`	`+ }`
	`717`	`+`
	`718`	`+ //Check if there are still running processes on the given ports`
	`719`	`+ for(let asyncProcess of this.asyncProcesses) {`
	`720`	`+ let processes: any[] = await findProcess("port", asyncProcess.port);`
	`721`	`+ if(processes.length > 0) {`
	`722`	`+ for(let proc of processes) {`
	`723`	`+ if(proc.name == asyncProcess.name \|\| proc.name == asyncProcess.name + ".exe") {`
	`724`	`+ try {`
	`725`	`+ process.kill(proc.pid);`
	`726`	`+ } catch(e) {`
	`727`	`+ console.error("Error killing id " + proc.pid, e);`
	`728`	`+ }`
`724`	`729`	`}`
`725`		`- })`
`726`		`- });`
`727`		`- })`
	`730`	`+ }`
	`731`	`+ }`
	`732`	`+ }`
`728`	`733`	`}`
`729`	`734`	`}`
`730`	`735`
`731`		`- private cleanUp(): void {`
`732`		`- this.killAsyncProcesses();`
	`736`	`+ private async cleanUp(): Promise<void> {`
	`737`	`+ await this.killAsyncProcesses();`
`733`	`738`	`ConsoleUtils.restoreDevonDirectory();`
`734`	`739`	`}`
`735`	`740`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ export class Katacoda extends Runner {`
`51`	`51`	`this.assetManager = new KatacodaAssetManager(path.join(this.outputPathTutorial, "assets"));`
`52`	`52`	`}`
`53`	`53`
`54`		`- destroy(playbook: Playbook): void {`
	`54`	`+ async destroy(playbook: Playbook): Promise<void> {`
`55`	`55`	`let tutorialDirectoryName = path.basename(playbook.path);`
`56`	`56`	`this.renderTemplate("intro.md", path.join(this.outputPathTutorial, "intro.md"), { description: playbook.description, tutorialPath: tutorialDirectoryName });`
`57`	`57`	`fs.writeFileSync(this.outputPathTutorial + 'finish.md', "");`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ export class VsCode extends Runner {`
`33`	`33`	`});`
`34`	`34`	`}`
`35`	`35`
`36`		`- destroy(playbook: Playbook): void {`
	`36`	`+ async destroy(playbook: Playbook): Promise<void> {`
`37`	`37`	`this.cleanUp();`
`38`	`38`	`}`
`39`	`39`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ export class WikiConsole extends WikiRunner {`
`10`	`10`	`super.init(playbook);`
`11`	`11`	`}`
`12`	`12`
`13`		`- destroy(playbook: Playbook): void {`
	`13`	`+ async destroy(playbook: Playbook): Promise<void> {`
`14`	`14`	`super.destroy(playbook);`
`15`	`15`	`}`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ export class WikiEclipse extends WikiRunner {`
`7`	`7`	`super.init(playbook);`
`8`	`8`	`}`
`9`	`9`
`10`		`- destroy(playbook: Playbook): void {`
	`10`	`+ async destroy(playbook: Playbook): Promise<void> {`
`11`	`11`	`super.destroy(playbook);`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ export class WikiEditor extends WikiRunner {`
`7`	`7`	`super.init(playbook);`
`8`	`8`	`}`
`9`	`9`
`10`		`- destroy(playbook: Playbook): void {`
	`10`	`+ async destroy(playbook: Playbook): Promise<void> {`
`11`	`11`	`super.destroy(playbook);`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ export class WikiVsCode extends WikiRunner {`
`7`	`7`	`super.init(playbook);`
`8`	`8`	`}`
`9`	`9`
`10`		`- destroy(playbook: Playbook): void {`
	`10`	`+ async destroy(playbook: Playbook): Promise<void> {`
`11`	`11`	`super.destroy(playbook);`
`12`	`12`	`}`
`13`	`13`	`}`