@aj-shadow/z-abs-funclayer-engine-server 0.0.0-aj-beta.221

package/project/server/address/subnet.js

@@ -0,0 +1,60 @@
+
+'use strict';
+
+
+class Subnet {
+  static calculate(virtualInterface) {
+    if('IPv4' === virtualInterface.family) {
+      const addressSplit = 'localhost' !== virtualInterface.address ? virtualInterface.address : '127.0.0.1';
+      return Subnet.subnet(addressSplit.split('.'), virtualInterface.netmask.split('.'), 10);
+    }
+    else if('IPv6' === virtualInterface.family) {
+      const address = 'localhost' !== virtualInterface.address ? virtualInterface.address : '::1';
+      return Subnet.subnet(Subnet.formatIPv6(virtualInterface.address), Subnet.formatIPv6(virtualInterface.netmask), 16);
+    }
+  }
+  
+  static formatIPv6(address) {
+    const addressParts = address.split(':');
+    const index = addressParts.findIndex((addressPart) => {
+      return '' === addressPart;
+    });
+    if(-1 !== index) {
+      const size = addressParts.length - 2;
+      addressParts.splice(index, 2, ...Array(8 - size).fill(0));
+    }
+    return addressParts;
+  }
+  
+  static subnet(addressParts, netmaskParts, base) {
+    let subnet = '';
+    let i = 0
+    for(; i < addressParts.length - 1; ++i) {
+      subnet += (Number.parseInt(addressParts[i], base) & Number.parseInt(netmaskParts[i], base)) + (10 === base ? '.' : ':');
+    }
+    subnet += (Number.parseInt(addressParts[i], base) & Number.parseInt(netmaskParts[i], base));
+    return `${subnet}/${Subnet.netmaskBits(netmaskParts, base)}`;
+  }
+  
+  static netmaskBits(netmaskParts, base) {
+    if(10 === base) {
+      let sum = 0;
+      for(let i = 0; i < netmaskParts.length; ++i) {
+        const binary = Number.parseInt(netmaskParts[i]).toString(2).padStart(8, '0');
+        const firstZero = binary.indexOf('0');
+        if(-1 === firstZero) {
+          sum += 8;
+        }
+        else {
+          sum += firstZero;
+          return sum;
+        }
+      }
+    }
+    else {
+      return 'ToBeImpl';
+    }
+  }
+}
+
+module.exports = Subnet;

package/project/server/communication/messages/messages-s-to-c/message-execution-started.js

@@ -0,0 +1,17 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageExecutionStarted {
+  constructor(chosen, clientLogSettings, clientConsoleLogSettings) {
+    this.msgId = AppProtocolConst.EXECUTION_STARTED;
+    this.chosen = chosen;
+    this.clientLogSettings = clientLogSettings;
+    this.clientConsoleLogSettings = clientConsoleLogSettings;
+  }
+}
+
+
+module.exports = MessageExecutionStarted;

package/project/server/communication/messages/messages-s-to-c/message-execution-stopped.js

@@ -0,0 +1,14 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageExecutionStopped {
+  constructor() {
+    this.msgId = AppProtocolConst.EXECUTION_STOPPED;
+  }
+}
+
+
+module.exports = MessageExecutionStopped;

package/project/server/communication/messages/messages-s-to-c/message-test-case-debug-paused.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseDebugPaused {
+  constructor(stack, scriptId, script, actorIndex) {
+    this.msgId = AppProtocolConst.TEST_CASE_DEBUG_PAUSED;
+    this.stack = stack;
+    this.scriptId = scriptId;
+    this.script = script;
+    this.actorIndex = actorIndex;
+  }
+}
+
+
+module.exports = MessageTestCaseDebugPaused;

package/project/server/communication/messages/messages-s-to-c/message-test-case-log.js

@@ -0,0 +1,25 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseLog  {
+  constructor(type, date, actor, actorPath, log, group, fileName, lineNumber, sourceType, inners, data) {
+    this.msgId = AppProtocolConst.LOG;
+    this.type = type;
+    this.date = date;
+    this.actor = actor;
+    this.actorPath = actorPath;
+    this.log = log;
+    this.group = group;
+    this.fileName = fileName;
+    this.lineNumber = lineNumber;
+    this.sourceType = sourceType;
+    this.inners = inners;
+    this.data = data;
+  }
+}
+
+
+module.exports = MessageTestCaseLog;

package/project/server/communication/messages/messages-s-to-c/message-test-case-started.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseStarted {
+  constructor(index, iterationTs, name, sutName, actors, timestamp, isExecuted) {
+    this.msgId = AppProtocolConst.TEST_CASE_STARTED;
+    this.index = index;
+    this.iterationTs = iterationTs;
+    this.name = name;
+    this.sutName = sutName;
+    this.actors = actors;
+    this.timestamp = timestamp;
+    this.isExecuted = isExecuted;
+  }
+}
+
+
+module.exports = MessageTestCaseStarted;

package/project/server/communication/messages/messages-s-to-c/message-test-case-state.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseState {
+  constructor(actorIndex, actorOrderIndex, stateIndex, stateResultIndex) {
+    this.msgId = AppProtocolConst.TEST_CASE_STATE;
+    this.actorIndex = actorIndex;
+    this.actorOrderIndex = actorOrderIndex;
+    this.stateIndex = stateIndex;
+    this.stateResultIndex = stateResultIndex;
+  }
+}
+
+
+module.exports = MessageTestCaseState;

package/project/server/communication/messages/messages-s-to-c/message-test-case-stopped.js

@@ -0,0 +1,22 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseStopped {
+  constructor(index, iterationTs, duration, resultId, resultIdPre, resultIdExec, resultIdPost, last) {
+    this.msgId = AppProtocolConst.TEST_CASE_STOPPED;
+    this.index = index;
+    this.iterationTs = iterationTs;
+    this.duration = duration;
+    this.resultId = resultId;
+    this.resultIdPre = resultIdPre;
+    this.resultIdExec = resultIdExec;
+    this.resultIdPost = resultIdPost;
+    this.last = last;
+  }
+}
+
+
+module.exports = MessageTestCaseStopped;

package/project/server/communication/messages/messages-s-to-c/message-test-stage-started.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestStageStarted {
+  constructor(index, type, iterationTs, timestamp, isExecuted) {
+    this.msgId = AppProtocolConst.TEST_STAGE_STARTED;
+    this.index = index;
+    this.type = type;
+    this.iterationTs = iterationTs;
+    this.timestamp = timestamp;
+    this.isExecuted = isExecuted;
+  }
+}
+
+
+module.exports = MessageTestStageStarted;

package/project/server/communication/messages/messages-s-to-c/message-test-stage-stopped.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestStageStopped {
+  constructor(index, type, iterationTs, duration, resultId) {
+    this.msgId = AppProtocolConst.TEST_STAGE_STOPPED;
+    this.index = index;
+    this.type = type;
+    this.iterationTs = iterationTs;
+    this.duration = duration;
+    this.resultId = resultId;
+  }
+}
+
+
+module.exports = MessageTestStageStopped;

package/project/server/communication/messages/messages-s-to-c/message-test-suite-started.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestSuiteStarted {
+  constructor(index, timestamp) {
+    this.msgId = AppProtocolConst.TEST_SUITE_STARTED;
+    this.index = index;
+    this.timestamp = timestamp;
+  }
+}
+
+
+module.exports = MessageTestSuiteStarted;

package/project/server/communication/messages/messages-s-to-c/message-test-suite-stopped.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestSuiteStopped {
+  constructor(index, timestamp, duration, resultId, last) {
+    this.msgId = AppProtocolConst.TEST_SUITE_STOPPED;
+    this.index = index;
+    this.timestamp = timestamp;
+    this.duration = duration;
+    this.resultId = resultId;
+    this.last = last;
+  }
+}
+
+
+module.exports = MessageTestSuiteStopped;

package/project/server/communication/messages/messages-s-to-w/message-test-case-debug-actor-index-ok.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseDebugActorIndexOk {
+  constructor(sessionId, actorIndex) {
+    this.msgId = AppProtocolConst.TEST_CASE_DEBUG_ACTOR_INDEX_OK;
+    this.sessionId = sessionId;
+    this.actorIndex = actorIndex;
+  }
+}
+
+module.exports = MessageTestCaseDebugActorIndexOk;

package/project/server/communication/messages/messages-w-to-s/message-test-case-debug-actor-index.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class MessageTestCaseDebugActorIndex {
+  constructor(actorIndex) {
+    this.msgId = AppProtocolConst.TEST_CASE_DEBUG_ACTOR_INDEX;
+    this.actorIndex = actorIndex;
+  }
+}
+
+
+module.exports = MessageTestCaseDebugActorIndex;

package/project/server/debug/debug-step-over.js

@@ -0,0 +1,54 @@
+
+'use strict';
+
+
+class DebugStepOver {
+  constructor(client) {
+    this.client = client;
+    this.lineNumber = 0;
+    this.topStack = null;
+    this.breakPoint = null;
+  }
+  
+  async setBreakpoint(topStack) {
+    this.topStack = topStack;
+    const location = topStack?.location;
+    if(location) {
+      ++location.lineNumber;
+      if(location.lineNumber > this.lineNumber) {
+        this.lineNumber = location.lineNumber;
+        try {
+          const result = await this.client.Debugger.getPossibleBreakpoints({
+            start: location
+          });
+          if(0 !== result?.locations.length) {
+            const locations = result.locations;
+            let location = result.locations[0];
+            for(let i = 0; i < locations.length; ++i) {
+              if('call' === locations[i].type) {
+                location = locations[i];
+                break;
+              }
+            }
+            this.breakPoint = await this.client.Debugger.setBreakpoint({location:location});
+          }
+        }
+        catch(e) {}
+      }
+    }
+  }
+  
+  async removeBreakpoint() {
+    if(this.breakPoint) {
+      await this.client.Debugger.removeBreakpoint({breakpointId:this.breakPoint.breakpointId});
+      this.breakPoint = null;
+    }
+  }
+  
+  sameScript(scriptName) {
+    return this.topStack?.scriptName === scriptName;
+  }
+}
+
+
+module.exports = DebugStepOver;

package/project/server/debug/debugger.js

@@ -0,0 +1,102 @@
+
+'use strict';
+
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const Path = require('path');
+
+
+class Debugger {
+  constructor() {
+    this.breakpoints = [];
+    this.runBreakpoints = [];
+    this.scriptCacheScriptId = new Map();
+    this.scriptCacheUrl = new Map();
+  }
+  /*
+  static calculateBreakpointUrl(sut, fut, tc, breakpoint) {
+    let url = `${ActorPathDist.getActorDistActorsPath()}/${breakpoint.name}`;
+    if(url.startsWith('/')) {
+      url = `file://${Path.normalize(url)}`;
+    }
+    else {
+      url = `file:///${Path.normalize(url)}`;
+    }
+    url = url.replace(/\\/g, '/');
+    return url;
+  }
+  
+  setBreakpoints(breakpoints) {
+    this.breakpoints = breakpoints;
+  }
+  
+  getBreakpoints() {
+    return this.breakpoints;
+  }
+  
+  setBreakpoint(breakpoint) {
+    const index = this._findIndexBreakpoint(breakpoint);
+    if(-1 === index) {
+      this.breakpoints.push(breakpoint);
+    }
+    else {
+      this.breakpoints[index] = breakpoint;
+    }
+  }
+  
+  getBreakpoint(breakpoint) {
+    const index = this._findIndexBreakpoint(breakpoint);
+    if(-1 !== index) {
+      return this.breakpoints[index];
+    }
+  }
+  
+  removeBreakpoint(breakpoint) {
+    const index = this._findIndexBreakpoint(breakpoint);
+    if(-1 !== index) {
+      this.breakpoints.splice(index, 1);
+    }
+  }
+  
+  setRunBreakpoint(breakpoint) {
+    this.runBreakpoints.push(breakpoint);
+  }
+  
+  clearRunBreakpoints() {
+    this.runBreakpoints = [];
+  }
+  
+  scriptParsed(parameters) {
+    this.scriptCacheScriptId.set(parameters.scriptId, parameters);
+    this.scriptCacheUrl.set(parameters.url, parameters);
+  }
+  
+  getScriptParameters(scriptId) {
+   return this.scriptCacheScriptId.get(scriptId);
+  }
+  
+  getScriptParametersFromUrl(url) {
+    return this.scriptCacheUrl.get(url);
+  }
+  
+  _findIndexBreakpoint(breakpoint) {
+    return this.breakpoints.findIndex((foundBreakpoint) => {
+      return foundBreakpoint.name === breakpoint.name
+        && foundBreakpoint.lineNumber === breakpoint.lineNumber;
+    });
+  }
+  
+  findbreakpointInBreakpoints(breakpoint) {
+    return !!this.breakpoints.find((serchBreakpoint) => {
+      return serchBreakpoint.lineNumber === breakpoint.lineNumber;
+    });
+  }
+  
+  findbreakpointInRunBreakpoints(breakpoint) {
+    return !!this.runBreakpoints.find((serchBreakpoint) => {
+      return serchBreakpoint.lineNumber === breakpoint.lineNumber;
+    });
+  }*/
+}
+
+
+module.exports = Debugger;

package/project/server/debug-dashboard/debug-dashboard.js

@@ -0,0 +1,14 @@
+
+'use strict';
+
+const GaugeManager = require('./gauge-manager');
+
+
+class DebugDashboard {
+  constructor() {
+    this.gaugeManager = new GaugeManager();
+  }
+}
+
+
+module.exports = DebugDashboard;

package/project/server/debug-dashboard/gauge-manager.js

@@ -0,0 +1,44 @@
+
+'use strict';
+
+const Gauge = require('./gauge');
+
+
+class GaugeManager {
+  constructor() {
+    this.gauges = new Map();
+  }
+  
+  create(group, family, name, minValue, maxValue) {
+    const gaugeData = {
+      group: group,
+      family: family,
+      name: name,
+      key: `${group}:${family}:${name}`,
+      value: 0,
+      samples: [0],
+      nbrOfSamples: 0,
+      meanValue: 0,
+      minValue: minValue,
+      maxValue: maxValue,
+      update: () => {
+        ddb.writeln('GAUGE', gaugeData.key + ':', gaugeData.value);
+      }
+    };
+    this.gauges.set(gaugeData.key, gaugeData);
+    return new Gauge(gaugeData);
+  }
+  
+  exit() {
+    this.gauges = new Map();
+  }
+  
+  print() {
+    this.gauges.forEach((gaugeData) => {
+   //   ddb.writeln('GAUGE', gaugeData.key + ':', gaugeData.value);
+    });
+  }
+}
+
+
+module.exports = GaugeManager;

package/project/server/debug-dashboard/gauge.js

@@ -0,0 +1,37 @@
+
+'use strict';
+
+
+class Gauge {
+  constructor(gaugeData) {
+    this.gaugeData = gaugeData;
+  }
+  
+  set(value) {
+    this.gaugeData.value = value;
+//    this.gaugeData.samples.push(value);
+    this.gaugeData.meanValue = (this.gaugeData.meanValue + (value - this.gaugeData.meanValue) / ++this.gaugeData.nbrOfSamples);
+    this.gaugeData.update();
+  }
+  
+  inc() {
+    ++this.gaugeData.value;
+//    this.gaugeData.samples.push(this.gaugeData.value);
+    this.gaugeData.meanValue = (this.gaugeData.meanValue + (this.gaugeData.value - this.gaugeData.meanValue) / ++this.gaugeData.nbrOfSamples);
+    this.gaugeData.update();
+  }
+  
+  dec() {
+    --this.gaugeData.value;
+//    this.gaugeData.samples.push(this.gaugeData.value);
+    this.gaugeData.meanValue = (this.gaugeData.meanValue + (this.gaugeData.value - this.gaugeData.meanValue) / ++this.gaugeData.nbrOfSamples);
+    this.gaugeData.update();
+  }
+  
+  print() {
+//    ddb.writeln('- GAUGE', this.gaugeData.key + ':', this.gaugeData.value);
+  }
+}
+
+
+module.exports = Gauge;