@aj-shadow/z-abs-corelayer-cs 0.0.0-aj-beta.221

package/project/clientServer/communication/core-protocol/serializer-message-request.js

@@ -0,0 +1,84 @@
+
+'use strict';
+
+const EncoderConst = require('./encoder-const');
+
+
+class SerializerMessageRequest {
+  constructor(jsonFunc) {
+    this.jsonFunc = jsonFunc;
+    this.encoder = null;
+    this.params = [];
+  }
+  
+  init(encoder) {
+    this.encoder = encoder;
+  }
+  
+  do(msg, cachedTexts) {
+    this.params = [];
+    const encoder = this.encoder;
+    const size = this._calculateData(msg);
+    const buffer = encoder.createBuffer(size);
+    encoder.setGuid(msg.id);
+    encoder.setUint16(msg.requests.length);
+    this._writeRequests(msg, cachedTexts);
+    return buffer;
+  }
+  
+  _calculateData(msg) {
+    const encoder = this.encoder;
+    let size = EncoderConst.GuidSize + EncoderConst.Uint16Size;
+    for(let i = 0; i < msg.requests.length; ++i) {
+      const request = msg.requests[i];
+      size += EncoderConst.Uint16Size + (!msg.isServiceAction ? EncoderConst.CtSize : encoder.getStringBytes(request.name)) + EncoderConst.Uint8Size;
+      if(request.params) {
+        const params = JSON.stringify(request.params, this.jsonFunc);
+        size += encoder.getStringBytes(params);
+        this.params.push(params);
+      }
+      else {
+        this.params.push(null);
+        size += encoder.calculateDynamicBytes(0);
+      }
+      if(request.sessionId) {
+        size += EncoderConst.GuidSize;
+      }
+    }
+    return size;
+  }
+  
+  _writeRequest(request, cachedTexts, index, isServiceAction) {
+    const encoder = this.encoder;
+    encoder.setUint16(request.index);
+    if(!isServiceAction) {
+      encoder.setCtString(request.name, cachedTexts);
+    }
+    else {
+      encoder.setString(request.name);
+    }
+    if(request.params) {
+      const params = this.params[index];
+      encoder.setString(params);
+    }
+    else {
+      encoder.setString('');
+    }
+    if(request.sessionId) {
+      encoder.setUint1_0(1, true);
+      encoder.setGuid(request.sessionId);
+    }
+    else {
+      encoder.setUint1_0(0, true);
+    }
+  }
+  
+  _writeRequests(msg, cachedTexts) {
+    msg.requests.forEach((request, index) => {
+      this._writeRequest(request, cachedTexts, index, msg.isServiceAction);
+    });
+  }
+}
+
+
+module.exports = SerializerMessageRequest;

package/project/clientServer/communication/core-protocol/serializer-message-response.js

@@ -0,0 +1,90 @@
+
+'use strict';
+
+const EncoderConst = require('./encoder-const');
+
+
+class SerializerMessageResponse {
+  static SIZE = 2 + 16;
+  
+  constructor(jsonFunc) {
+    this.jsonFunc = jsonFunc;
+    this.encoder = null;
+    this.datas = [];
+  }
+  
+  init(encoder) {
+    this.encoder = encoder;
+  }
+  
+  do(msg, cachedTexts) {
+    this.datas = [];
+    const encoder = this.encoder;
+    const size = this._calculateData(msg);
+    const buffer = encoder.createBuffer(size);
+    encoder.setGuid(msg.id);
+    encoder.setUint16(msg.responses.length);
+    this._writeResponses(msg, cachedTexts);
+    return buffer;
+  }
+  
+  _calculateData(msg) {
+    const encoder = this.encoder;
+    let size = SerializerMessageResponse.SIZE;
+    for(let i = 0; i < msg.responses.length; ++i) {
+      const response = msg.responses[i];
+      size += EncoderConst.Uint16Size + (!msg.isServiceAction ? EncoderConst.CtSize : encoder.getStringBytes(response.name)) + EncoderConst.Uint8Size;
+      if('success' === response.result.code) {
+        if(response.data) {
+          const data = JSON.stringify(response.data, this.jsonFunc);
+          size += encoder.getStringBytes(data);
+          this.datas.push(data);
+        }
+        else {
+          this.datas.push(null);
+        }
+      }
+      else {
+        const data = JSON.stringify(response.result.msg, this.jsonFunc);
+        size += encoder.getStringBytes(data);
+        this.datas.push(data);
+      }
+    }
+    return size;
+  }
+  
+  _writeResponse(response, index, cachedTexts, isServiceAction) {
+    const encoder = this.encoder;
+    encoder.setUint16(response.index);
+    if(!isServiceAction) {
+      encoder.setCtString(response.name, cachedTexts);
+    }
+    else {
+      encoder.setString(response.name);
+    }
+    if('success' === response.result.code) {
+      if(response.data) {
+        encoder.setUint8(2);
+        const data = this.datas[index];
+        encoder.setString(data);
+      }
+      else {
+        encoder.setUint8(1);
+      }
+    }
+    else {
+      encoder.setUint8(0);
+      const data = this.datas[index];
+      encoder.setString(data);
+    }
+  }
+  
+  _writeResponses(msg, cachedTexts) {
+    msg.responses.forEach((response, index) => {
+      this._writeResponse(response, index, cachedTexts, msg.isServiceAction);
+    });
+  }
+}
+
+
+module.exports = SerializerMessageResponse;

package/project/clientServer/communication/core-protocol/serializer-message-service-init-request.js

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const EncoderConst = require('./encoder-const');
+
+
+class SerializerMessageServiceInitRequest {
+  constructor(jsonFunc) {
+    this.jsonFunc = jsonFunc;
+    this.encoder = null;
+    this.params = [];
+  }
+  
+  init(encoder) {
+    this.encoder = encoder;
+  }
+  
+  do(msg, cachedTexts) {
+    const encoder = this.encoder;
+    const size = this._calculateData(msg);
+    const buffer = encoder.createBuffer(size);
+    encoder.setString(msg.nodeName);
+    encoder.setGuid(msg.nodeId);
+    encoder.setUint8(msg.nodeType);
+    return buffer;
+  }
+  
+  _calculateData(msg) {
+    const encoder = this.encoder;
+    return encoder.getStringBytes(msg.nodeName) + EncoderConst.GuidSize + EncoderConst.Uint8Size;
+  }
+}
+
+
+module.exports = SerializerMessageServiceInitRequest;

package/project/clientServer/communication/core-protocol/serializer-message-service-init-response.js

@@ -0,0 +1,29 @@
+
+'use strict';
+
+
+class SerializerMessageServiceInitResponse {
+  constructor(jsonFunc) {
+    this.jsonFunc = jsonFunc;
+    this.encoder = null;
+    this.params = [];
+  }
+  
+  init(encoder) {
+    this.encoder = encoder;
+  }
+  
+  do(msg, cachedTexts) {
+    const encoder = this.encoder;
+    const size = this._calculateData(msg);
+    const buffer = encoder.createBuffer(size);
+    encoder.setGuid(msg.id);
+  }
+  
+  _calculateData(msg) {
+    const encoder = this.encoder;
+  }
+}
+
+
+module.exports = SerializerMessageServiceInitResponse;

package/project/clientServer/communication/core-protocol/serializer.js

@@ -0,0 +1,188 @@
+
+'use strict';
+
+const CoreMessage = require('./core-message');
+const EncoderConst = require('./encoder-const');
+const SerializerMessageRequest = require('./serializer-message-request');
+const SerializerMessageResponse = require('./serializer-message-response');
+const SerializerMessageServiceInitRequest = require('./serializer-message-service-init-request');
+const CoreProtocolConst = require('./core-protocol-const');
+const AppSerializer = require('../app-protocol/app-serializer');
+const TextCache = require('../cache/text-cache');
+
+
+//        0                   1                   2                   3
+//        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//       |      0        |     flags     |            message id         |
+//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//       |             data size                                         |
+//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//       |  nbrOfBuffers |       data buffer size[i]...                  |
+//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//       |                           data buffers                        |
+//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//       |  
+//       +-+-+-+-+-+-+-+-+-+-+-+-+-
+//
+//       total size: UInt32 - 
+//       flags: UInt8 - b0: ENVELOPE (FALSE/TRUE) | b1: DATA (JSON/BIN) | b2: DATA-BUFFERS (FALSE/TRUE)
+//       data size: UInt32 - 
+//       nbrOfBuffers: UInt8 (OPTIONAL)
+//       data buffer size: UInt32 * nbrOfBuffers (OPTIONAL)
+//       data buffer: UInt8 * [data size]
+class Serializer {
+  constructor(name, Encoder, textCache) {
+    this.name = name;
+    this.appSerializer = new AppSerializer();
+    this.textCache = textCache ? textCache : new TextCache(`SERIALIZER-${name}`, null);
+    this.encoder = new Encoder(this.textCache);
+    this.cachedTexts = {
+      nbr: 0,
+      texts: []
+    };
+    this.appSerializer.init(this.encoder);
+    this.appSerializer.register(CoreProtocolConst.REQUEST, new SerializerMessageRequest(Serializer.jsonFunc));
+    this.appSerializer.register(CoreProtocolConst.RESPONSE, new SerializerMessageResponse(Serializer.jsonFunc));
+    this.appSerializer.register(CoreProtocolConst.SERVICE_INIT_REQUEST, new SerializerMessageServiceInitRequest(Serializer.jsonFunc));
+  }
+  
+  register(msgId, appSerializer) {
+     this.appSerializer.register(msgId, appSerializer);
+  }
+  
+  do(msg, dataBuffers, envelope) {
+    //console.log('SERIALIZE:', msg.msgId);
+    const buffers = [];
+    try {
+      const msgId = msg.msgId ? ('number' === typeof msg.msgId ? msg.msgId : 0) : 0;
+      this._do(buffers, envelope, msg, dataBuffers, msgId);
+      //console.log('SERIALIZE - DONE', buffers);
+      return buffers;
+    }
+    catch(err) {
+      ddb.error(err, msg);
+      throw err;
+    }
+  }
+  
+  clear() {
+    this.appSerializer.clear();
+  }
+  
+  static jsonFunc = (key, value) => {
+    if('bigint' === typeof value) {
+      return {
+        bigint__: true,
+        value: value.toString()
+      };
+    }
+    else {
+      return value;
+    }
+  }
+  
+  _do(buffers, envelope, msg, dataBuffers, msgId) {
+    const encoder = this.encoder;
+    let sizeData = 0;
+    let msgDataBuffer = null;
+    let sizeTextCache = 0;
+    const cachedTexts = this.cachedTexts;
+    cachedTexts.nbr = 0;
+    cachedTexts.texts = [];
+    const nbrOfBuffers = dataBuffers ? dataBuffers.length : 0;
+    if(!envelope) {
+      envelope = msg.envelope;
+    }
+    const hasEnvelope = !!envelope;
+    let isBinary = !!msg.isBinary;
+    const hasBuffers = 0 !== nbrOfBuffers;
+    let hasTextCache = false;
+    const isServiceAction = !!msg.isServiceAction;
+    if(isBinary) {
+      msgDataBuffer = msg.bin;
+      sizeData += encoder.calculateBytesFromBin(msgDataBuffer);
+    }
+    else {
+      if(0 !== msgId) {
+        msgDataBuffer = this.appSerializer.do(msgId, msg instanceof CoreMessage ? msg.msg : msg, cachedTexts);
+        hasTextCache = 0 !== cachedTexts.nbr;
+        if(hasTextCache) {
+          sizeTextCache += 1;
+          for(let i = 0; i < cachedTexts.texts.length; ++i) {
+            const text = cachedTexts.texts[i].text;
+            if(text) {
+              sizeTextCache += 2;
+              sizeTextCache += encoder.getStringBytes(text);
+            }
+          }
+        }
+      }
+      if(!msgDataBuffer) {
+        msgDataBuffer = JSON.stringify(msg, Serializer.jsonFunc);
+        sizeData += encoder.calculateBytesFromString(msgDataBuffer);
+      }
+      else {
+        isBinary = true;
+        sizeData += encoder.calculateBytesFromBin(msgDataBuffer);
+      }
+    }
+    this._encode(true, encoder, hasEnvelope, isBinary, hasBuffers, hasTextCache, isServiceAction, envelope, msgId, sizeTextCache, sizeData, msgDataBuffer, msg.cachedTextBuffer, cachedTexts, nbrOfBuffers, dataBuffers);
+    buffers.push(encoder.createBuffer(encoder.offset));
+    this._encode(false, encoder, hasEnvelope, isBinary, hasBuffers, hasTextCache, isServiceAction, envelope, msgId, sizeTextCache, sizeData, msgDataBuffer, msg.cachedTextBuffer, cachedTexts, nbrOfBuffers, dataBuffers);
+    if(hasBuffers) {
+      dataBuffers.forEach((dataBuffer) => {
+        buffers.push(dataBuffer);                        // DATA buffers
+      });
+    }
+    encoder.clear();
+  }
+  
+  _encode(doCalculate, encoder, hasEnvelope, isBinary, hasBuffers, hasTextCache, isServiceAction, envelope, msgId, sizeTextCache, sizeData, msgDataBuffer, cachedTextBuffer, cachedTexts, nbrOfBuffers, dataBuffers) {
+    encoder.calculate(doCalculate);
+    encoder.setUint8(0);
+    encoder.setBool1_0(hasEnvelope, false);
+    encoder.setBool1_1(isBinary, false);
+    encoder.setBool1_2(hasBuffers, false);
+    encoder.setBool1_3(hasTextCache || cachedTextBuffer, false);
+    encoder.setBool1_4(isServiceAction, true);
+    encoder.setUint16(msgId);
+    if(hasEnvelope) {
+      encoder.setString(envelope.serviceName);
+      encoder.setGuidArray(envelope.routes);
+      encoder.setGuidArray(envelope.recordRoutes);
+    }
+    if(cachedTextBuffer) {
+      const size = encoder.calculateBytesFromBin(cachedTextBuffer);
+      encoder.setDynamicBytes(size);
+      encoder.setRawBinary(cachedTextBuffer, size);
+    }
+    else if(hasTextCache) {
+      encoder.setDynamicBytes(sizeTextCache);
+      encoder.setUint8(cachedTexts.nbr); // cached texts
+      for(let i = 0; i < cachedTexts.texts.length; ++i) {
+        const text = cachedTexts.texts[i];
+        if(text.text) {
+          encoder.setUint16(text.id);
+          encoder.setString(text.text);
+        }
+      }
+    }
+    encoder.setDynamicBytes(sizeData);
+    if(isBinary) { // data
+      encoder.setRawBinary(msgDataBuffer, sizeData);
+    }
+    else {
+      encoder.setRawString(msgDataBuffer, sizeData);
+    }
+    if(hasBuffers) {
+      encoder.setUint8(nbrOfBuffers);  // nbr of data buffers
+      dataBuffers.forEach((dataBuffer) => {
+        encoder.setUint32(dataBuffer.byteLength); // size of data buffer[i]
+      });
+    }
+  }
+}
+
+
+module.exports = Serializer;

package/project/clientServer/communication/response-data.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+class ActionData {
+  constructor(result, data) {
+    this.result = result;
+    this.data = data;
+  }
+  
+  isSuccess() {
+    return 'success' === this.result.code;
+  }
+}
+
+
+module.exports = ActionData;

package/project/clientServer/communication/service-action.js

@@ -0,0 +1,29 @@
+
+'use strict';
+
+const CoreProtocolConst = require('./core-protocol/core-protocol-const');
+const ActionRequest = require('./action-request');
+
+
+class ServiceAction {
+  constructor(serviceName, ...params) {
+    this.msgId = CoreProtocolConst.REQUEST;
+    this.serviceName = serviceName;
+    this.actionRequest = new ActionRequest().add(this.constructor.name.substring(13), 0, ...params);
+    this.actionRequest.isServiceAction = true;
+    this.responses = [];
+  };
+  
+  setIds(requestId, sessionId) {
+    this.actionRequest.setIds(requestId, sessionId);
+  }
+  
+  setResponses(responses) {
+    if(responses) {
+      this.responses = responses;
+    }
+  }
+}
+
+
+module.exports = ServiceAction;

package/project/clientServer/debug-dashboard/garbage-collection.js

@@ -0,0 +1,27 @@
+
+'use strict';
+
+
+class GarbageCollection {
+  constructor() {
+    this.waiting = false;
+  }
+  
+  gc() {
+    if(window.gc) {
+      if(!this.waiting) {
+        this.waiting = true;
+        setTimeout(() => {
+          this.waiting = false;
+          window.gc();
+        }, 100);
+      }
+    }
+    else {
+      console.warn('Please start browser with \'--js-flags="--expose-gc"\'');
+    }
+  }
+}
+
+
+global.ddgc = new GarbageCollection();