Initial engine

Author: SchettlerKoehler

.gitignore

@@ -0,0 +1,2 @@
+/build/*
+/node_modules/*

assertions/index.ts

@@ -0,0 +1,19 @@
+import { RunResult } from "../engine/run_result";
+import { Step } from "../engine/step";
+import { Command } from "../engine/command";
+import { NoErrorCode } from "./noErrorCode";
+import { NoException } from "./noException";
+
+
+export class Assertions{
+
+    public noErrorCode(result: RunResult): Assertions {
+        NoErrorCode.run(result);
+        return this;
+    }
+
+    public noException(result: RunResult): Assertions {
+        NoException.run(result);
+        return this;
+    }
+}

assertions/noErrorCode.ts

@@ -0,0 +1,9 @@
+import { RunResult } from "../engine/run_result";
+
+export class NoErrorCode{
+    public static run(result: RunResult): void {
+        if(result.returnCode != 0){
+            throw new Error("returnCode is not 0");
+        }
+    }
+}

assertions/noException.ts

@@ -0,0 +1,9 @@
+import { RunResult } from "../engine/run_result";
+
+export class NoException {
+    public static run(result: RunResult): void {
+        if(result.exceptions.length > 0){
+            throw new Error("Unexpected exception.");
+        }
+    }
+}

buildRun.ps1

@@ -0,0 +1,6 @@
+tsc
+Copy-Item -Force -Recurse -Path $PSScriptRoot\engine\parser.def -Destination $PSScriptRoot\build\engine\parser.def
+Copy-Item -Force -Recurse -Path $PSScriptRoot\playbooks\ -Destination $PSScriptRoot\build
+Copy-Item -Force -Recurse -Path $PSScriptRoot\environments\ -Destination $PSScriptRoot\build
+Copy-Item -Force -Recurse -Exclude *.ts -Path $PSScriptRoot\runners\ -Destination $PSScriptRoot\build
+node $PSScriptRoot\build\engine\run.js

engine/command.ts

@@ -0,0 +1,4 @@
+export class Command{
+    public name: string;
+    public parameters: string;
+}

engine/engine.ts

@@ -0,0 +1,96 @@
+import { Environment } from "./environment";
+import { Playbook } from "./playbook";
+import { Runner } from "./runner";
+import { RunResult } from "./run_result";
+
+
+export class Engine {
+
+    private runners: Map<string, Runner> = new Map<string, Runner>();
+    private variables: Map<string, any> = new Map<string, any>();
+
+    constructor(private environmentName: string, private environment: Environment, private playbook: Playbook) { }
+
+    async run() {
+        console.log("Environment: " + this.environmentName);
+        if (! await this.isEnvironmentComplete()) {
+            if (this.environment.failOnIncomplete) {
+                throw "Environment incomplete: " + this.environmentName;
+            }
+            console.log("Environment incomplete: " + this.environmentName);
+            return;
+        }
+        for (let runnerIndex in this.environment.runners) {
+            (await this.getRunner(this.environment.runners[runnerIndex])).init(this.playbook);
+        }
+
+        for (let stepIndex in this.playbook.steps) {
+            for (let lineIndex in this.playbook.steps[stepIndex].lines) {
+                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();
+                        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);
+                        break;
+                    }
+                }
+            }
+        }
+
+        for (let runnerIndex in this.environment.runners) {
+            (await this.getRunner(this.environment.runners[runnerIndex])).destroy(this.playbook);
+        }
+    }
+
+    public setVariable(name: string, value: any) {
+        this.variables.set(name, value);
+    }
+
+    private async isEnvironmentComplete(): Promise<boolean> {
+        for (let stepIndex in this.playbook.steps) {
+            for (let lineIndex in this.playbook.steps[stepIndex].lines) {
+                let isSupported = false;
+                for (let runnerIndex in this.environment.runners) {
+                    if ((await this.getRunner(this.environment.runners[runnerIndex])).supports(this.playbook.steps[stepIndex].lines[lineIndex].name)) {
+                        isSupported = true;
+                        break;
+                    }
+                }
+                if (!isSupported) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    private async getRunner(name: string): Promise<Runner> {
+        if (!this.runners.has(name)) {
+            await this.loadRunner(name);
+        }
+        return this.runners.get(name);
+    }
+
+    private async loadRunner(name: string) {
+        let imp = await import("../runners/" + name + "/index");
+        let map = new Map<string, any>();
+        for (let index in imp) {
+            map.set(index.toLowerCase(), imp[index]);
+        }
+        let runner: Runner = new (map.get(name.toLowerCase()));
+        runner.registerGetVariableCallback((name) => this.variables.get(name));
+        runner.registerSetVariableCallback((name, value) => this.setVariable(name, value));
+        runner.path = __dirname + "/../runners/" + name + "/";
+        runner.name = name;
+        runner.playbookName = this.playbook.name;
+        runner.playbookPath = this.playbook.path;
+        this.runners.set(name, runner);
+    }
+}

engine/environment.ts

@@ -0,0 +1,5 @@
+
+export interface Environment{
+    failOnIncomplete: boolean;
+    runners: string[];
+}

engine/parser.def

@@ -0,0 +1,64 @@
+start
+  = headline
+    description
+    step+
+
+headline
+  = "=" _ string ___
+  
+description
+  = "====" ___
+    descriptionlines
+  	"====" ___ 
+
+descriptionlines
+  = descriptionline+ { return { "descriptionlines": text()}; }
+  
+descriptionline
+  = !"====" string __ 
+  
+step
+  = (
+      "====" ___
+      stepinner
+      steptextafterlines
+      "====" __
+    )
+  / stepinner
+  
+stepinner
+  = steptextlines?
+   "[step]" ___
+   "--" ___
+   steplines
+   "--" __
+
+steptextlines
+  = steptextline* { return { "steptextlines": text()}; }
+
+steptextline
+  = !"[step]" string __
+  
+steptextafterlines
+  = steptextafterline* { return { "steptextafterlines": text()}; }
+
+steptextafterline
+  = !"====" string __
+ 
+steplines
+  = stepline+
+
+stepline
+  = !"--" string __ { return { "stepline": text()}; }
+  
+string "string"
+  = [a-zA-Z0-9.(),;:/-_- ]+ { return text(); }
+
+_ "whitespace"
+  = [ \t]*
+ 
+__ "linebreak"
+  = [ \t\n\r]*
+  
+___ "linebreak"
+  = [ \t\n\r]+

engine/parser.ts

@@ -0,0 +1,68 @@
+import { Playbook } from "./playbook";
+import { Step } from "./step";
+import { Command } from "./command";
+const pegjs = require("pegjs");
+const tspegjs = require("ts-pegjs");
+const fs = require('fs');
+
+
+export class Parser {
+    private parser;
+
+    constructor() {
+        let def = fs.readFileSync(__dirname + "/parser.def", 'utf8');
+        this.parser = pegjs.generate(def);
+
+    }
+
+    parse(inputFile: string): Playbook {
+        let input = fs.readFileSync(inputFile, 'utf8');
+        let parseResult = this.parser.parse(input);
+        let result = new Playbook();
+        result.title = parseResult[0][2];
+        result.description = parseResult[1][2].descriptionlines;
+        for(let index in parseResult[2]){
+            let step = new Step();
+            step.text = this.getText(parseResult,index);;
+            step.lines = this.getLines(parseResult,index);
+            step.textAfter = this.getTextAfter(parseResult, index);
+
+            result.steps.push(step);
+        }
+
+        return result;
+    }
+
+    getText(parseResult, index){
+        try {
+            return parseResult[2][index][0].steptextlines || parseResult[2][index][2][0].steptextlines;
+        } catch (error) {
+            return parseResult[2][index][2][0].steptextlines;
+        }
+    }
+
+    getLines(parseResult, index):Command[]{
+        try {
+            return (parseResult[2][index][5][0].stepline || parseResult[2][index][2][5][0].stepline).split("\r\n").filter(e => e != '').map(e => this.createCommand(e));
+        } catch (error) {
+            return parseResult[2][index][2][5][0].stepline.split("\r\n").filter(e => e != '').map(e => this.createCommand(e));
+        }
+    }
+
+    createCommand(line: string): Command{
+        let re =/([^(]+)\(([^)]*)\)/;
+        let result = re.exec(line);
+        let retVal = new Command();
+        retVal.name = result[1].trim();
+        retVal.parameters = result[2];
+        return retVal;
+    }
+
+    getTextAfter(parseResult, index){
+        try {
+            return parseResult[2][index][3].steptextafterlines || "";
+        } catch (error) {
+            return "";
+        }
+    }
+}