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

package/project/server/stack/api/sdp/sdp-encoder.js

@@ -0,0 +1,40 @@
+
+'use strict';
+
+
+class SdpEncoder {
+  static encode(sdpMessage) {
+    const lines = [];
+    // --- Session-level mandatory lines ---
+    lines.push(`v=${sdpMessage.version}`);
+    lines.push(`o=${sdpMessage.origin.username} ${sdpMessage.origin.sessionId} ${sdpMessage.origin.sessionVersion} ` + `${sdpMessage.origin.netType} ${sdpMessage.origin.addrType} ${sdpMessage.origin.unicastAddress}`);
+    lines.push(`s=${sdpMessage.sessionName}`);
+    lines.push(`t=${sdpMessage.timing.start} ${sdpMessage.timing.stop}`);
+    // --- Session-level attributes ---
+    for(const attr of sdpMessage.sessionAttributes) {
+      if(null === attr.value) {
+        lines.push(`a=${attr.name}`);
+      }
+      else {
+        lines.push(`a=${attr.name}:${attr.value}`);
+      }
+    }
+    // --- Media sections ---
+    for(const m of sdpMessage.media) {
+      const payloadList = m.payloadTypes.join(" ");
+      lines.push(`m=${m.kind} ${m.port} ${m.protocol} ${payloadList}`);
+      for(const attr of m.attributes) {
+        if(null === attr.value) {
+          lines.push(`a=${attr.name}`);
+        }
+        else {
+          lines.push(`a=${attr.name}:${attr.value}`);
+        }
+      }
+    }
+    return lines.join("\r\n") + "\r\n";
+  }
+}
+
+
+module.exports = SdpEncoder;

package/project/server/stack/api/sdp/sdp-media-attribute.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+
+class SdpMediaAttribute {
+  constructor(name, value = null) {
+    this.name = name; // e.g., "rtpmap"
+    this.value = value;
+  }
+}
+
+
+module.exports = SdpMediaAttribute;

package/project/server/stack/api/sdp/sdp-media-session.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+
+class SdpMediaSession {
+  constructor() {
+    this.kind = ""; // audio | video | application
+    this.port = 0;
+    this.protocol = ""; // RTP/SAVPF, UDP/TLS/RTP/SAVPF, etc.
+    this.payloadTypes = []; // e.g., [96, 97, 98]
+    this.attributes = []; // a= lines inside m= section
+  }
+}
+
+
+module.exports = SdpMediaSession;

package/project/server/stack/api/sdp/sdp-message.js

@@ -0,0 +1,17 @@
+
+'use strict';
+
+
+class SdpMessage {
+  constructor() {
+    this.version = 0;
+    this.origin = new Origin(); // o=
+    this.sessionName = ""; // s=
+    this.timing = new Timing(); // t=
+    this.media = []; // m= sections
+    this.sessionAttributes = []; // a= at session level
+  }
+}
+
+
+module.exports = SdpMessage;

package/project/server/stack/api/sdp/sdp-origin.js

@@ -0,0 +1,17 @@
+
+'use strict';
+
+
+class SdpOrigin {
+  constructor() {
+    this.username = "-";
+    this.sessionId = "";
+    this.sessionVersion = "";
+    this.netType = "IN";
+    this.addrType = "IP4";
+    this.unicastAddress = "";
+  }
+}
+
+
+module.exports = SdpOrigin;

package/project/server/stack/api/sdp/sdp-session-attribute.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+
+class SdpSessionAttribute {
+  constructor(name, value = null) {
+    this.name = name; // e.g., "ice-ufrag"
+    this.value = value;
+  }
+}
+
+
+module.exports = SdpSessionAttribute;

package/project/server/stack/api/sdp/sdp-timing.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+class SdpTiming {
+  this.username = "-";
+  this.sessionId = "";
+  this.sessionVersion = "";
+  this.netType = "IN";
+  this.addrType = "IP4";
+  this.unicastAddress = "";
+}
+
+
+module.exports = SdpTiming;

package/project/server/stack/api/text-protocol-header.js

@@ -0,0 +1,35 @@
+
+'use strict';
+
+
+class TextProtocolHeader {
+  static parseValue(value) {
+    if(typeof value === 'string') {
+      return value;
+    }
+    else if(typeof value === 'number') {
+      return '' + value;
+    }
+    else if(typeof value === 'boolean') {
+      return value ? 'true' : 'false';
+    }
+    else {
+      return null;
+    }
+  }
+  
+  static addHeader(headers, name, value) {
+    if(undefined !== value) {
+      const convertedValue = TextProtocolHeader.parseValue(value);
+      if(convertedValue) {
+        if(!headers.has(name)) {
+          headers.set(name, []);
+        }
+        headers.get(name).push(convertedValue);
+      }
+    }
+  }
+}
+
+
+module.exports = TextProtocolHeader;

package/project/server/stack/factory/stack-components-helpers.js

@@ -0,0 +1,22 @@
+
+'use strict';
+
+const Os = require('os');
+
+
+class StackComponentsHelpers {
+  static _template(strings, ...keys) {
+    return ((...values) => {
+      const dict = values[values.length - 1] || {};
+      const result = [strings[0].replace(new RegExp('\n', 'g'), Os.EOL)];
+      keys.forEach((key, i) => {
+        const value = Number.isInteger(key) ? values[key] : dict[key];
+        result.push(value, strings[i + 1].replace(new RegExp('\n', 'g'), Os.EOL));
+      });
+      return result.join('');
+    });
+  }
+}
+
+
+module.exports = StackComponentsHelpers;

package/project/server/stack/factory/stack-components-template-base-actors.js

@@ -0,0 +1,124 @@
+
+'use strict';
+
+const ActorTypeConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-type-const');
+
+
+class StackComponentsTemplateBaseActors {
+  constructor(templates) {
+    this.templates = [
+      {
+        name: 'Local',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Condition',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Originating',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'RealSut',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Sut',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Proxy',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Terminating',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Intercepting',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'ActorPartPre',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'ActorPartPost',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      },
+      {
+        name: 'Msg',
+        templateNames: [],
+        templates: [],
+        markupNodes: [],
+        markupStyles: [],
+        markups: []
+      }
+    ];
+    templates.forEach((template) => {
+      let id = ActorTypeConst.getId(template.type);
+      if(!id) {
+        if('actorpartpre' === template.type) {
+          id = 8;
+        }
+        else if('actorpartpost' === template.type) {
+          id = 9;
+        }
+        else if('msg' === template.type) {
+          id = 10;
+        }
+        else {
+          return;
+        }
+      }
+      this.templates[id].templateNames.push(template.displayName);
+      this.templates[id].templates.push(template.template);
+      this.templates[id].markupNodes.push(template.markupNodes);
+      this.templates[id].markupStyles.push(template.markupStyle),
+      this.templates[id].markups.push(template.markup);
+    });
+  }
+}
+
+module.exports = StackComponentsTemplateBaseActors;

package/project/server/stack/factory/stack-components-template-base-test-cases.js

@@ -0,0 +1,22 @@
+
+'use strict';
+
+
+class StackComponentsTemplateBaseTestCases {
+  constructor(templates) {
+    this.templates = new Map();
+    templates.forEach((template) => {
+      this.templates.set(template.displayName, {
+        displayName: template.displayName,
+        regressionFriendly: template.regressionFriendly,
+        template: template.template,
+        testDataViews: template.testDataViews,
+        markupNodes: template.markupNodes,
+        markup: template.markup,
+        createTestCase: template.createTestCase
+      });
+    });
+  }
+}
+
+module.exports = StackComponentsTemplateBaseTestCases;

package/project/server/stack/factory/stack-components-templates-actors.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const StackComponentsHelpers = require('./stack-components-helpers');
+
+
+class StackComponentsTemplatesActors {
+  
+  static _template(strings, ...keys) {
+    return StackComponentsHelpers._template(strings, ...keys);
+  }
+}
+
+
+module.exports = StackComponentsTemplatesActors;

package/project/server/stack/factory/stack-components-templates-test-cases.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const StackComponentsHelpers = require('./stack-components-helpers');
+
+
+class StackComponentsTemplatesTestCases {
+    
+  static _template(strings, ...keys) {
+    return StackComponentsHelpers._template(strings, ...keys);
+  }
+}
+
+
+StackComponentsTemplatesTestCases.VALIDATE_NONE = 0;
+StackComponentsTemplatesTestCases.VALIDATE_SUCCESS = 1;
+StackComponentsTemplatesTestCases.VALIDATE_WARNING = 2;
+StackComponentsTemplatesTestCases.VALIDATE_ERROR = 3;
+
+module.exports = StackComponentsTemplatesTestCases;

package/project/server/stack/managers/client-manager/client-manager.js

@@ -0,0 +1,193 @@
+
+'use strict';
+
+const Manager = require('../manager');
+const BrowserData = require('../../stacks/browser-data');
+const ConnectionInstance = require('../../stacks/connection-instance');
+const ConnectionClient = require('../../stacks/connection-client');
+const PendingConst = require('../../pending/pending-const');
+const PendingContext = require('../../pending/pending-context');
+const ConnectionWeb = require('../../stacks/connection-web');
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+const FactoryNew = require('z-abs-corelayer-cs/clientServer/factory/factory-new');
+const LogDataStackType = require('z-abs-funclayer-engine-cs/clientServer/log/log-data-stack-type');
+
+
+class ClientManager extends Manager {
+  constructor(executionContext) {
+    super('client', executionContext);
+    this.connections = new Map();
+  }
+  
+  getConnection(stackName, connectionInstanceData, actor, reuse, srcAddress, dstAddress, options) {
+    let connection = null;
+    let browserData = null;
+    if(options.messageSelector) {
+      throw new Error('messageSelector is not implemented.');
+    }
+    const connectionInstanceParsed = ConnectionInstance.parse(connectionInstanceData);
+    if(reuse) {
+      connection = this.getToReuse(stackName, (type) => {
+        if('client' === type) {
+          return this._getConnectionClientKey(stackName, options, srcAddress, dstAddress);
+        }
+        else if('web' === type) {
+          browserData = this._createBrowserData(srcAddress, dstAddress);
+          return this._getConnectionWebKey(stackName, browserData);
+        }
+      });
+      if(connection) {
+        connectionInstanceParsed.connectionInstance.connection = connection;
+        connection.actor = actor;
+        connection.addPendingInner(PendingConst.ACTOR, actor);
+        if(connection.connectionWorker) {
+          connection.connectionWorker.setConnectionInstance(connectionInstanceParsed.connectionInstance);
+          connection.connectionWorker.setConnectionInstanceUpgrade(connectionInstanceParsed.connectionInstanceUpgrade);
+        }
+        connection.sharedManager = this.sharedManager;
+        connection.executionId = this.executionContext.executionData.id;
+        connection.logIpStack(() => `USE STACK: ${connection.name}`, LogDataStackType.USE, '74ee23f9-b5b1-4dcf-91d4-4de46aac4767');
+        if(connection.onReuse) {
+          const pendingContext = new PendingContext(PendingConst.ACTOR);
+          connection.pendingStartContext(pendingContext, 'reuse');
+          if(browserData) {
+            connection.setBrowserData(browserData);
+          }
+          connection.onReuse(browserData, (c, err) => {
+            if(!err) {
+              connection.pendingDoneContext(pendingContext, 'reuse', connection);
+            }
+            else {
+              connection.pendingErrorContext(pendingContext, 'reuse', err);
+            }
+          });
+          return
+        }
+        connection.pendingResultContext('reuse', connection);
+      }
+    }
+    if(!connection) {
+      const factory = StackComponentsFactory.createClient(stackName);
+      const connection = FactoryNew.create(factory, ++this.id, this.type, actor, options);
+      connectionInstanceParsed.connectionInstance.connection = connection;
+      if(connection.connectionWorker) {
+        connection.connectionWorker.setConnectionInstance(connectionInstanceParsed.connectionInstance);
+        connection.connectionWorker.setConnectionInstanceUpgrade(connectionInstanceParsed.connectionInstanceUpgrade);
+      }
+      connection.sharedManager = this.sharedManager;
+      connection.executionId = this.executionContext.executionData.id;
+      if(!reuse) {
+        this.connections.set(connection.id, connection);
+      }
+      else {
+        this.setUsing(connection);
+      }
+      if(connection instanceof ConnectionClient) {
+        connection.connect(connectionInstanceParsed.connectionInstanceUpgrade, dstAddress, srcAddress, this.dnsUrlCache, !reuse ? (connection, err) => {
+          this.connections.delete(connection.id);
+          connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, 'a9185bb6-82c5-4495-9416-3c26269c8944');
+        } : (connection, err) => {
+          if(!err) {
+            connection.errorData = [];
+            this.storeForReuse(stackName, 'client', this._getConnectionClientKey(stackName, options, srcAddress, dstAddress), connection);
+            connection.logIpStack(() => `STORE STACK: ${connection.name}`, LogDataStackType.STORE, '54532ce8-8cd9-49ff-95c0-0254f56b2d49');
+          }
+          else {
+            this.executionContext.testCaseStatistics.addErrorData(connection);
+            this.removeUsing(connection);
+            connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, 'c17524db-0da5-4a5d-b41e-9d7b7c8b80e0');
+          }
+        });
+        if(reuse) {
+          this.addConnectionType(stackName, 'client', connection);
+        }
+      }
+      else if(connection instanceof ConnectionWeb) {
+        !browserData && (browserData = this._createBrowserData(srcAddress, dstAddress));
+        connection.connect(browserData, this.dnsUrlCache, reuse, !reuse ? (connection, err) => {
+          this.connections.delete(connection.id);
+          connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, 'ca515a42-bec3-489c-81b1-55854bbaa132');
+        } : (connection, err) => {
+          if(!err) {
+            connection.errorData = [];
+            this.storeForReuse(stackName, 'web', this._getConnectionWebKey(stackName, browserData), connection);
+            connection.logIpStack(() => `STORE STACK: ${connection.name}`, LogDataStackType.STORE, '20ab42ef-473a-4520-a06c-1a465b691121');
+          }
+          else {
+            this.executionContext.testCaseStatistics.addErrorData(connection);
+            this.removeUsing(connection);
+            connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, 'ca515a42-bec3-489c-81b1-55854bbaa132');
+          }
+        });
+        if(reuse) {
+          this.addConnectionType(stackName, 'web', connection);
+        }
+      }
+    }
+  }
+  
+  switchProtocol(stackName, currentConnectionInstance, upgradedConnectionInstance, actor) {
+    if(!upgradedConnectionInstance || !(upgradedConnectionInstance instanceof ConnectionInstance)) {
+      throw new Error('Connection must be created with create() method.');
+    }
+    const factory = StackComponentsFactory.createClient(stackName);
+    const connection = FactoryNew.create(factory, ++this.id, this.type, actor, currentConnectionInstance.connection.options);
+    upgradedConnectionInstance.connection = connection;
+    currentConnectionInstance.connection.detachTo(upgradedConnectionInstance);
+    this.connections.set(connection.id, connection);
+    return connection;
+  }
+  
+  close(done) {
+    let connections = this.connections.size;
+    let usingReuseConnections = this.usingReuseConnections.size;
+    if(0 === connections && 0 === usingReuseConnections) {
+      done();
+      return;
+    }
+    this.connections.forEach((connection) => {
+      connection.closeForgottenConnections(() => {
+        connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, 'b0ca9eeb-8d69-4692-8dc2-cf28c3c56982');
+        if(0 === --connections) {
+          this.connections.clear();
+          done();
+        }
+      });
+    });
+    this.usingReuseConnections.forEach((connection) => {
+      connection.closeForgottenConnections(() => {
+        connection.logIpStack(() => `DEL STACK: ${connection.name}`, LogDataStackType.DEL, 'd2f333e0-8aef-422e-8709-d3f26225ce47');
+        if(0 === --usingReuseConnections) {
+          this.usingReuseConnections.clear();
+          done();
+        }
+      });
+    });
+  }
+  
+  _getConnectionClientKey(stackName, options, srcAddress, dstAddress) {
+    return `${stackName}_${options.transportLayer.transportType}_${srcAddress.host}:${srcAddress.port} => ${dstAddress.host}:${dstAddress.port}`;
+  }
+  
+  _getConnectionWebKey(stackName, browserData) {
+    return `${stackName}_${browserData.srcAddress.addressName}:${browserData.srcAddress.page}:${browserData.srcAddress.incognitoBrowser}`;
+  }
+  
+  _createBrowserData(srcAddress, dstAddress) {
+    if(!Array.isArray(dstAddress)) {
+      return new BrowserData(srcAddress, dstAddress);
+    }
+    else {
+      if(2 !== dstAddress.length) {
+      }
+      else {
+        const address = dstAddress[0].clone();
+        address.setProxy(dstAddress[1]);
+        return new BrowserData(srcAddress, address);
+      }
+    }
+  }
+}
+
+
+module.exports = ClientManager;

package/project/server/stack/managers/connection-manager/connection-data.js

@@ -0,0 +1,82 @@
+
+'use strict';
+
+const NetworkType = require('../../network/network-type');
+
+
+class ConnectionData {
+  static NOT_CONNECTED = 0;
+  static CONNECTED = 1;
+  static DISCONNECTED = 2;
+  
+  constructor(ownerId, id, actorIndex, transportLayer, address, isShared) {
+    this.ownerId = ownerId;
+    this.id = id;
+    this.actorIndex = actorIndex;
+    this.actionId = 0;
+    this.host = address.host ? address.host : '*';
+    this.port = 0 !== address.port ? address.port : '*';
+    this.transportLayer = transportLayer;
+    this.addressName = address.addressName;
+    this.family = address.family;
+    this.type = address.type;
+    this.isShared = isShared;
+    this.secure = false;
+    this.dataId = -1;
+    this._log = `${this.host}:${this.port}:${this.addressName ? this.addressName : ''}${this._getProperties()}`;
+  }
+  
+  static create(ownerId, id, actorIndex, transportLayer, addressName, type, host, port, family, isShared) {
+    return new ConnectionData(ownerId, id, actorIndex, transportLayer, {addressName, host, port, type, family}, isShared);
+  }
+  
+  update(host, port, family) {
+    this.host = host;
+    this.port = port;
+    this.family = family;
+    this._log = `${host}:${port}:${this.addressName ? this.addressName : ''}${this._getProperties()}`;
+  }
+  
+  getLog() {
+    return this._log;
+  }
+  
+  _getProperties() {
+    if(this.transportLayer.transportProperties) {
+      const properties = [];
+      this.transportLayer.transportProperties.forEach((value, name) => {
+        if('string' === typeof value) {
+          properties.push(`${name}: ${value}`);
+        }
+        else {
+          properties.push(`${name}: "${value}"`);
+        }
+      });
+      return ` \uD83D\uDD27 [${properties.join(', ')}]`;
+    }
+    else {
+      return '';
+    }
+  }
+  
+  toJSON() {
+    return {
+      ownerId: this.ownerId,
+      id: this.id,
+      actorIndex: this.actorIndex,
+      actionId: this.actionId,
+      host: this.host,
+      port: this.port,
+      transportLayer: this.transportLayer,
+      name: this.addressName, // RENAME: affects sequence diagram
+      family: this.family,
+      type: this.type,
+      isShared: this.isShared,
+      secure: this.secure,
+      dataId: this.dataId
+    };
+  }
+}
+
+
+module.exports = ConnectionData;