@signumjs/monitor
Version:
Monitor transactions on Signum Network blockchain
468 lines (405 loc) • 13.6 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = global || self, factory(global.sig$monitor = {}));
}(this, (function (exports) { 'use strict';
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
var VoidLogger = /*#__PURE__*/function () {
function VoidLogger() {
_classCallCheck(this, VoidLogger);
}
_createClass(VoidLogger, [{
key: "debug",
value: function debug(msg) {}
}, {
key: "error",
value: function error(msg) {}
}, {
key: "log",
value: function log(msg) {}
}]);
return VoidLogger;
}();
var voidLogger = new VoidLogger();
var isNode = function isNode() {
return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
};
var EventEmitter = /*#__PURE__*/function () {
function EventEmitter() {
_classCallCheck(this, EventEmitter);
if (isNode()) {
var Events = require('events');
this._emitter = new Events();
} else {
this._emitter = {
on: function on(name, cb) {
window.addEventListener(name, function (e) {
return cb(e.detail);
});
},
once: function once(name, cb) {
var singleCallback = function singleCallback(data) {
cb(data);
};
window.addEventListener(name, function (e) {
singleCallback(e.detail);
window.removeEventListener(name, singleCallback);
});
},
off: function off(name, cb) {
window.removeEventListener(name, cb);
},
emit: function emit(name, payload) {
window.dispatchEvent(new window.CustomEvent(name, {
detail: payload
}));
}
};
}
}
_createClass(EventEmitter, [{
key: "off",
value: function off(eventName, fn) {
this._emitter.off(eventName, fn);
}
}, {
key: "on",
value: function on(eventName, fn) {
this._emitter.on(eventName, fn);
}
}, {
key: "once",
value: function once(eventName, fn) {
this._emitter.once(eventName, fn);
}
}, {
key: "emit",
value: function emit(eventName, payload) {
this._emitter.emit(eventName, payload);
}
}]);
return EventEmitter;
}();
var MonitorEvents = {
Fulfilled: '@signumjs/monitor/fulfilled',
Timeout: '@signumjs/monitor/timeout'
};
var Monitor = /*#__PURE__*/function () {
function Monitor(args) {
_classCallCheck(this, Monitor);
this._timeoutSecs = -1;
this._emitter = new EventEmitter();
this._intervalSecs = -1;
this._startTime = -1;
this._handle = undefined;
var asyncFetcherFn = args.asyncFetcherFn,
compareFn = args.compareFn,
intervalSecs = args.intervalSecs,
key = args.key,
logger = args.logger,
timeoutSecs = args.timeoutSecs;
if (intervalSecs < 1) {
throw new Error('interval must be greater than zero');
}
this._key = key;
this._intervalSecs = intervalSecs;
this._timeoutSecs = timeoutSecs;
this._asyncFetcher = asyncFetcherFn;
this._compareFn = compareFn;
this._logger = logger || voidLogger;
}
_createClass(Monitor, [{
key: "startTime",
get: function get() {
return this._startTime;
}
}, {
key: "intervalSecs",
get: function get() {
return this._intervalSecs;
}
}, {
key: "key",
get: function get() {
return this._key;
}
}, {
key: "timeoutSecs",
get: function get() {
return this._timeoutSecs;
}
}, {
key: "serialize",
value: function serialize() {
return JSON.stringify({
intervalSecs: this._intervalSecs,
timeoutSecs: this._timeoutSecs,
key: this._key,
startTime: this._startTime,
asyncFetcherFn: Monitor._serializeFunction(this._asyncFetcher),
compareFn: Monitor._serializeFunction(this._compareFn)
});
}
}, {
key: "_debug",
value: function _debug(msg) {
this._logger.debug("[".concat(this._key, "] - ").concat(msg));
}
}, {
key: "_resetStartTime",
value: function _resetStartTime() {
this._startTime = -1;
}
}, {
key: "hasStarted",
value: function hasStarted() {
return this.startTime !== -1;
}
}, {
key: "isExpired",
value: function isExpired() {
return this.hasStarted() ? (Date.now() - this._startTime) / 1000 >= this._timeoutSecs : false;
}
}, {
key: "start",
value: function start() {
var _this = this;
this._debug('Monitoring...');
if (this.isExpired()) {
this._debug('Monitor expired');
this.stop();
return this;
}
this._handle = setTimeout(function () {
return __awaiter(_this, void 0, void 0, function* () {
try {
var data = yield this._asyncFetcher();
this._debug("Fetched: ".concat(JSON.stringify(data, null, '\t')));
var predicateFulfilled = this._compareFn(data);
if (predicateFulfilled) {
this._debug('Monitor predicate fulfilled');
this._emitter.emit(MonitorEvents.Fulfilled, {
key: this.key,
data: data
});
this._resetStartTime();
} else if (!this.isExpired()) {
this.start();
} else {
this._debug('Monitor timed out');
this._emitter.emit(MonitorEvents.Timeout, {
key: this.key
});
this._resetStartTime();
}
} catch (e) {
this._debug("Monitor failed: ".concat(e));
}
});
}, this._intervalSecs * 1000);
if (!this.hasStarted()) {
this._startTime = Date.now();
}
return this;
}
}, {
key: "stop",
value: function stop() {
clearTimeout(this._handle);
this._startTime = -1;
}
}, {
key: "onTimeout",
value: function onTimeout(fn) {
this._emitter.on(MonitorEvents.Timeout, fn);
return this;
}
}, {
key: "onFulfilled",
value: function onFulfilled(fn) {
this._emitter.on(MonitorEvents.Fulfilled, fn);
return this;
}
}], [{
key: "deserialize",
value: function deserialize(serializedMonitor) {
var autoStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var args = JSON.parse(serializedMonitor);
var monitor = new Monitor(Object.assign(Object.assign({}, args), {
asyncFetcherFn: Monitor._deserializeFunction(args.asyncFetcherFn),
compareFn: Monitor._deserializeFunction(args.compareFn)
}));
monitor._startTime = args.startTime;
if (autoStart && args.startTime > -1) {
monitor.start();
}
return monitor;
}
}, {
key: "_serializeFunction",
value: function _serializeFunction(fn) {
return fn.toString().replace(/\s+/g, ' ');
}
}, {
key: "_deserializeFunction",
value: function _deserializeFunction(serialized) {
return eval(serialized);
}
}]);
return Monitor;
}();
var MemoryMonitorRepository = /*#__PURE__*/function () {
function MemoryMonitorRepository() {
_classCallCheck(this, MemoryMonitorRepository);
this.monitors = {};
}
_createClass(MemoryMonitorRepository, [{
key: "get",
value: function get(key) {
return Promise.resolve(this.monitors[key] || null);
}
}, {
key: "getAll",
value: function getAll() {
var _this = this;
var monitors = Object.keys(this.monitors).map(function (k) {
return _this.monitors[k];
});
return Promise.resolve(monitors);
}
}, {
key: "insert",
value: function insert(monitor) {
if (this.monitors[monitor.key]) {
return Promise.reject("Monitor with key '[".concat(monitor.key, "]' already exists"));
}
this.monitors[monitor.key] = monitor;
monitor.stop();
return Promise.resolve();
}
}, {
key: "remove",
value: function remove(key) {
if (this.monitors[key]) {
delete this.monitors[key];
}
return Promise.resolve();
}
}]);
return MemoryMonitorRepository;
}();
var DefaultOptions = {
autoStart: true
};
var LocalStorageMonitorRepository = /*#__PURE__*/function () {
function LocalStorageMonitorRepository(storage) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DefaultOptions;
_classCallCheck(this, LocalStorageMonitorRepository);
this.storage = storage;
this.options = options;
}
_createClass(LocalStorageMonitorRepository, [{
key: "get",
value: function get(key) {
var item = this.storage.getItem(key);
var monitor = item && Monitor.deserialize(item, this.options.autoStart);
return Promise.resolve(monitor || null);
}
}, {
key: "getAll",
value: function getAll() {
var monitors = [];
for (var i = 0; i < this.storage.length; ++i) {
var key = this.storage.key(i);
var serializedMonitor = this.storage.getItem(key);
monitors.push(Monitor.deserialize(serializedMonitor, this.options.autoStart));
}
return Promise.resolve(monitors);
}
}, {
key: "insert",
value: function insert(monitor) {
if (this.storage.getItem(monitor.key)) {
return Promise.reject("Model with key '[".concat(monitor.key, "]' already exists"));
}
this.storage.setItem(monitor.key, monitor.serialize());
return Promise.resolve();
}
}, {
key: "remove",
value: function remove(key) {
if (this.storage.getItem(key)) {
this.storage.removeItem(key);
}
return Promise.resolve();
}
}]);
return LocalStorageMonitorRepository;
}();
var ConsoleLogger = /*#__PURE__*/function () {
function ConsoleLogger() {
_classCallCheck(this, ConsoleLogger);
}
_createClass(ConsoleLogger, [{
key: "debug",
value: function debug(msg) {
console.log("[DEBUG]: ".concat(msg));
}
}, {
key: "error",
value: function error(msg) {
console.log("[ERROR]: ".concat(msg));
}
}, {
key: "log",
value: function log(msg) {
console.log("[LOG]: ".concat(msg));
}
}]);
return ConsoleLogger;
}();
var consoleLogger = new ConsoleLogger();
exports.ConsoleLogger = ConsoleLogger;
exports.LocalStorageMonitorRepository = LocalStorageMonitorRepository;
exports.MemoryMonitorRepository = MemoryMonitorRepository;
exports.Monitor = Monitor;
Object.defineProperty(exports, '__esModule', { value: true });
})));