agora-foundation 1.0.0

package/lib/worker/interactor.js

@@ -0,0 +1,378 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkerInteractor = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.date.now.js");
+require("core-js/modules/es.function.bind.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _isNumber = _interopRequireDefault(require("lodash/isNumber"));
+var _workerFactory = require("./worker-factory");
+var _constants = require("./constants");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _events = require("../utilities/events");
+var _raceCondition = require("../utilities/race-condition");
+var _excluded = ["isSuccess"];
+var MAX_WAIT_TIME = 10000;
+var WorkerInteractor = exports.WorkerInteractor = /*#__PURE__*/function () {
+  function WorkerInteractor() {
+    (0, _classCallCheck2["default"])(this, WorkerInteractor);
+    (0, _defineProperty2["default"])(this, "_eventEmitter", new _events.AgoraEventEmitter());
+    this._handleMessageCallback = this._handleMessageCallback.bind(this);
+    this._handleErrorCallback = this._handleErrorCallback.bind(this);
+    this._handleMessageErrorCallback = this._handleMessageErrorCallback.bind(this);
+    this._logWorker = this._spawnNewWorker();
+    this._attachEventHandlers();
+  }
+  return (0, _createClass2["default"])(WorkerInteractor, [{
+    key: "clearTempLogs",
+    value: function clearTempLogs() {
+      try {
+        return this._promisify({
+          type: _constants.WorkerDirectives.CLEAR_TEMP_LOGS,
+          data: {}
+        });
+      } catch (err) {
+        if (err.cause === 'timeout') {
+          throw new Error('[WorkerInteractor] failed to clear temp logs due to timeout error in worker', {
+            cause: err
+          });
+        }
+        throw err;
+      }
+    }
+  }, {
+    key: "setMaxRecords",
+    value: function () {
+      var _setMaxRecords = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(maxRecords) {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              if (!(0, _isNumber["default"])(maxRecords)) {
+                _context.next = 7;
+                break;
+              }
+              console.info("[WorkerInteractor] set maxRecords to ".concat(maxRecords));
+              _context.next = 5;
+              return this._promisify({
+                type: _constants.WorkerDirectives.SET_MAX_RECORDS,
+                data: {
+                  maxRecords: maxRecords
+                }
+              });
+            case 5:
+              _context.next = 8;
+              break;
+            case 7:
+              console.warn("[WorkerInteractor] cannot set maxRecords to an invalid number :".concat(maxRecords));
+            case 8:
+              _context.next = 15;
+              break;
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](0);
+              if (!(_context.t0.cause === 'timeout')) {
+                _context.next = 14;
+                break;
+              }
+              throw new Error('[WorkerInteractor] failed to set maxRecords due to timeout error in worker', {
+                cause: _context.t0
+              });
+            case 14:
+              throw _context.t0;
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 10]]);
+      }));
+      function setMaxRecords(_x) {
+        return _setMaxRecords.apply(this, arguments);
+      }
+      return setMaxRecords;
+    }()
+  }, {
+    key: "sendLog",
+    value: function sendLog(message, label) {
+      this._logWorker.postMessage({
+        type: _constants.WorkerDirectives.WRITE_LOG,
+        data: {
+          label: label,
+          message: message
+        }
+      });
+    }
+  }, {
+    key: "collectLogs",
+    value: function () {
+      var _collectLogs = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(labels) {
+        var _yield$this$_promisif, buffer, lastId, datefmt, file;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              _context2.next = 3;
+              return this._promisify({
+                type: _constants.WorkerDirectives.COLLECT_LOGS,
+                data: {
+                  labels: labels
+                }
+              });
+            case 3:
+              _yield$this$_promisif = _context2.sent;
+              buffer = _yield$this$_promisif.buffer;
+              lastId = _yield$this$_promisif.lastId;
+              datefmt = (0, _dayjs["default"])().format('YYYY-MM-DDTHH:mm:ssZ[Z]');
+              file = new File([buffer], "logs-".concat(datefmt, ".zip"), {
+                type: 'application/zip'
+              });
+              return _context2.abrupt("return", {
+                file: file,
+                lastId: lastId
+              });
+            case 11:
+              _context2.prev = 11;
+              _context2.t0 = _context2["catch"](0);
+              if (!(_context2.t0.cause === 'timeout')) {
+                _context2.next = 15;
+                break;
+              }
+              throw new Error('[WorkerInteractor] failed to collect logs due to timeout error in worker', {
+                cause: _context2.t0
+              });
+            case 15:
+              throw _context2.t0;
+            case 16:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 11]]);
+      }));
+      function collectLogs(_x2) {
+        return _collectLogs.apply(this, arguments);
+      }
+      return collectLogs;
+    }()
+  }, {
+    key: "deleteLogs",
+    value: function deleteLogs(labels, lastId) {
+      try {
+        return this._promisify({
+          type: _constants.WorkerDirectives.DELETE_LOGS,
+          data: {
+            labels: labels,
+            lastId: lastId
+          }
+        });
+      } catch (err) {
+        if (err.cause === 'timeout') {
+          throw new Error('[WorkerInteractor] failed to delete logs due to timeout error in worker', {
+            cause: err
+          });
+        }
+        throw err;
+      }
+    }
+  }, {
+    key: "persistBinary",
+    value: function persistBinary(id, buffer) {
+      try {
+        return this._promisify({
+          type: _constants.WorkerDirectives.PERSIST_BUFFER,
+          data: {
+            id: id,
+            buffer: buffer
+          }
+        }, [buffer]);
+      } catch (err) {
+        if (err.cause === 'timeout') {
+          throw new Error('[WorkerInteractor] failed to persist binary due to timeout error in worker', {
+            cause: err
+          });
+        }
+        throw err;
+      }
+    }
+  }, {
+    key: "unpersistBinary",
+    value: function unpersistBinary(id) {
+      try {
+        return this._promisify({
+          type: _constants.WorkerDirectives.UNPERSIST_BUFFER,
+          data: {
+            id: id
+          }
+        });
+      } catch (err) {
+        if (err.cause === 'timeout') {
+          throw new Error('[WorkerInteractor] failed to unpersist binary due to timeout error in worker', {
+            cause: err
+          });
+        }
+        throw err;
+      }
+    }
+  }, {
+    key: "getBinary",
+    value: function () {
+      var _getBinary = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(id) {
+        var _yield$this$_promisif2, buffer;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return this._promisify({
+                type: _constants.WorkerDirectives.GET_BUFFER,
+                data: {
+                  id: id
+                }
+              });
+            case 3:
+              _yield$this$_promisif2 = _context3.sent;
+              buffer = _yield$this$_promisif2.buffer;
+              return _context3.abrupt("return", buffer);
+            case 8:
+              _context3.prev = 8;
+              _context3.t0 = _context3["catch"](0);
+              if (!(_context3.t0.cause === 'timeout')) {
+                _context3.next = 12;
+                break;
+              }
+              throw new Error('[WorkerInteractor] failed to get binary due to timeout error in worker', {
+                cause: _context3.t0
+              });
+            case 12:
+              throw _context3.t0;
+            case 13:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 8]]);
+      }));
+      function getBinary(_x3) {
+        return _getBinary.apply(this, arguments);
+      }
+      return getBinary;
+    }()
+  }, {
+    key: "collectLogsOnFs",
+    value: function () {
+      var _collectLogsOnFs = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(logDirPath) {
+        var _yield$this$_promisif3, buffer, datefmt, file;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this._promisify({
+                type: _constants.WorkerDirectives.COLLECT_LOGS_ON_FS,
+                data: {
+                  logDirPath: logDirPath
+                }
+              });
+            case 2:
+              _yield$this$_promisif3 = _context4.sent;
+              buffer = _yield$this$_promisif3.buffer;
+              datefmt = (0, _dayjs["default"])().format('YYYY-MM-DDTHH:mm:ssZ[Z]');
+              file = new File([buffer], "logs-".concat(datefmt, ".zip"), {
+                type: 'application/zip'
+              });
+              return _context4.abrupt("return", file);
+            case 7:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function collectLogsOnFs(_x4) {
+        return _collectLogsOnFs.apply(this, arguments);
+      }
+      return collectLogsOnFs;
+    }()
+  }, {
+    key: "_handleMessageCallback",
+    value: function _handleMessageCallback(message) {
+      var _message$data = message.data,
+        type = _message$data.type,
+        callId = _message$data.callId,
+        data = _message$data.data;
+      var isSuccess = data.isSuccess,
+        payload = (0, _objectWithoutProperties2["default"])(data, _excluded);
+      this._eventEmitter.emit(type, isSuccess, callId, payload);
+    }
+  }, {
+    key: "_handleErrorCallback",
+    value: function _handleErrorCallback(e) {
+      console.error('[WorkerInteractor] error occurred in worker:', e);
+    }
+  }, {
+    key: "_handleMessageErrorCallback",
+    value: function _handleMessageErrorCallback() {
+      console.error('[WorkerInteractor] worker message cannot be deserialized.');
+    }
+  }, {
+    key: "_attachEventHandlers",
+    value: function _attachEventHandlers() {
+      this._logWorker.addEventListener('message', this._handleMessageCallback);
+      this._logWorker.addEventListener('error', this._handleErrorCallback);
+      this._logWorker.addEventListener('messageerror', this._handleMessageErrorCallback);
+    }
+  }, {
+    key: "_spawnNewWorker",
+    value: function _spawnNewWorker() {
+      console.info('[WorkerInteractor] spawned a new log worker');
+      var logWorker = (0, _workerFactory.createWorkerInstance)();
+      return logWorker;
+    }
+  }, {
+    key: "_promisify",
+    value: function _promisify(payload, transfer) {
+      var _this = this;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      var _callback = function callback(_, __, ___) {};
+      var type = payload.type,
+        data = payload.data;
+      return (0, _raceCondition.timeout)(new Promise(function (resolve, reject) {
+        var callId = Date.now();
+        _callback = function callback(isSuccess, replyId, result) {
+          if (callId !== replyId) {
+            return;
+          }
+          _this._eventEmitter.off(type, _callback);
+          if (isSuccess) {
+            resolve(result);
+          } else {
+            reject("failed to ".concat(payload.type));
+          }
+        };
+        _this._eventEmitter.on(type, _callback);
+        if (transfer) {
+          _this._logWorker.postMessage({
+            type: type,
+            callId: callId,
+            data: data
+          }, transfer);
+        } else {
+          _this._logWorker.postMessage({
+            type: type,
+            callId: callId,
+            data: data
+          });
+        }
+      }), MAX_WAIT_TIME);
+    }
+  }]);
+}();

package/lib/worker/mutex.d.ts

@@ -0,0 +1,5 @@
+export declare class Mutex {
+    private mutex;
+    private _lock;
+    dispatch<T>(fn: (() => T) | (() => PromiseLike<T>)): Promise<T>;
+}

package/lib/worker/mutex.js

@@ -0,0 +1,65 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Mutex = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var Mutex = exports.Mutex = /*#__PURE__*/function () {
+  function Mutex() {
+    (0, _classCallCheck2["default"])(this, Mutex);
+    (0, _defineProperty2["default"])(this, "mutex", Promise.resolve());
+  }
+  return (0, _createClass2["default"])(Mutex, [{
+    key: "_lock",
+    value: function _lock() {
+      var begin = function begin() {};
+      this.mutex = this.mutex.then(function () {
+        return new Promise(begin);
+      });
+      return new Promise(function (res) {
+        begin = res;
+      });
+    }
+  }, {
+    key: "dispatch",
+    value: function () {
+      var _dispatch = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(fn) {
+        var unlock;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this._lock();
+            case 2:
+              unlock = _context.sent;
+              _context.prev = 3;
+              _context.next = 6;
+              return Promise.resolve(fn());
+            case 6:
+              return _context.abrupt("return", _context.sent);
+            case 7:
+              _context.prev = 7;
+              unlock();
+              return _context.finish(7);
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[3,, 7, 10]]);
+      }));
+      function dispatch(_x) {
+        return _dispatch.apply(this, arguments);
+      }
+      return dispatch;
+    }()
+  }]);
+}();

package/lib/worker/type.d.ts

@@ -0,0 +1 @@
+export type WorkerContext = Pick<typeof globalThis, 'postMessage' | 'addEventListener' | 'removeEventListener'>;

package/lib/worker/type.js

@@ -0,0 +1,6 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/worker/worker-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker/worker-entry.js

@@ -0,0 +1,5 @@
+"use strict";
+
+require("core-js/modules/web.self.js");
+var _workerInstaller = require("./worker-installer");
+(0, _workerInstaller.installHandler)(self);

package/lib/worker/worker-factory.d.ts

@@ -0,0 +1 @@
+export declare const createWorkerInstance: () => Worker;

package/lib/worker/worker-factory.js

@@ -0,0 +1,14 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWorkerInstance = void 0;
+var _workerEntry = _interopRequireDefault(require("./worker-entry"));
+//@ts-ignore
+
+var createWorkerInstance = exports.createWorkerInstance = function createWorkerInstance() {
+  return new _workerEntry["default"]();
+};

package/lib/worker/worker-installer.d.ts

@@ -0,0 +1,2 @@
+import { WorkerContext } from "./type";
+export declare const installHandler: (self: WorkerContext) => void;

package/lib/worker/worker-installer.js

@@ -0,0 +1,72 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installHandler = void 0;
+require("core-js/modules/es.date.now.js");
+require("core-js/modules/es.date.to-string.js");
+var _log = require("./handler/log");
+var _binary = require("./handler/binary");
+var _fsLog = require("./handler/fs-log");
+var _constants = require("./constants");
+var _reply = require("./handler/reply");
+var installHandler = exports.installHandler = function installHandler(self) {
+  console.log("[worker] worker initialzied.");
+  self.addEventListener("message", function (evt) {
+    if (evt.data) {
+      var _evt$data = evt.data,
+        type = _evt$data.type,
+        callId = _evt$data.callId;
+      if (type === _constants.WorkerDirectives.WRITE_LOG) {
+        var now = new Date();
+        var _evt$data$data = evt.data.data,
+          label = _evt$data$data.label,
+          message = _evt$data$data.message;
+        (0, _log.writeLog)(self, callId, {
+          label: label,
+          content: message,
+          created_at: +Date.now(),
+          timestamp: "".concat(now)
+        });
+      } else if (type === _constants.WorkerDirectives.SET_MAX_RECORDS) {
+        (0, _log.setMaxRecords)(self, callId, evt.data.data.maxRecords || 50000);
+      } else if (type === _constants.WorkerDirectives.COLLECT_LOGS) {
+        var _evt$data$data$labels = evt.data.data.labels,
+          labels = _evt$data$data$labels === void 0 ? [] : _evt$data$data$labels;
+        (0, _log.collectLogs)(self, callId, labels);
+      } else if (type === _constants.WorkerDirectives.DELETE_LOGS) {
+        var _evt$data$data2 = evt.data.data,
+          _evt$data$data2$label = _evt$data$data2.labels,
+          _labels = _evt$data$data2$label === void 0 ? [] : _evt$data$data2$label,
+          lastId = _evt$data$data2.lastId;
+        (0, _log.deleteLogs)(self, callId, _labels, lastId);
+      } else if (type === _constants.WorkerDirectives.PERSIST_BUFFER) {
+        var _evt$data$data3 = evt.data.data,
+          id = _evt$data$data3.id,
+          buffer = _evt$data$data3.buffer;
+        (0, _binary.persistBinary)(self, callId, id, new Blob([buffer]));
+      } else if (type === _constants.WorkerDirectives.UNPERSIST_BUFFER) {
+        var _id = evt.data.data.id;
+        (0, _binary.unpersistBinary)(self, callId, _id);
+      } else if (type === _constants.WorkerDirectives.GET_BUFFER) {
+        var _id2 = evt.data.data.id;
+        (0, _binary.getBuffer)(self, callId, _id2);
+      } else if (type === _constants.WorkerDirectives.CLEAR_TEMP_LOGS) {
+        (0, _binary.clearTempLogs)(self, callId);
+      } else if (type === _constants.WorkerDirectives.COLLECT_LOGS_ON_FS) {
+        var logDirPath = evt.data.data.logDirPath;
+        (0, _fsLog.collectLogsOnFs)(self, callId, logDirPath);
+      } else {
+        unsupported(self, callId, type);
+      }
+    }
+  });
+};
+var unsupported = function unsupported(self, callId, directive) {
+  (0, _reply.reply)(self, callId, directive, {
+    isSuccess: false,
+    message: "unsupported directive: ".concat(directive)
+  });
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "agora-foundation",
+  "version": "1.0.0",
+  "license": "MIT",
+  "scripts": {
+    "build": "agora-tc-transpile",
+    "test-browser": "agora-tc-test-karma-browser"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.23.5",
+    "@babel/plugin-proposal-decorators": "^7.23.5",
+    "@babel/plugin-transform-runtime": "^7.13.15",
+    "@babel/preset-env": "^7.23.5",
+    "@babel/preset-react": "^7.24.1",
+    "@babel/preset-typescript": "^7.23.3",
+    "core-js": "^3.33.3",
+    "@types/jasmine": "^5.1.4",
+    "@types/lodash": "^4.14.168",
+    "@types/node": "^20.11.30",
+    "tslib": "^2.6.2"
+  },
+  "dependencies": {
+    "async-await-retry": "^2.0.1",
+    "dayjs": "^1.10.4",
+    "dexie": "^3.0.3",
+    "jszip": "^3.10.1",
+    "lodash": "^4.17.21"
+  }
+}