@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.distributedcoordinator.js

@@ -0,0 +1,314 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import * as plugins from './plugins.js';
+import { SmartdataDb } from './classes.db.js';
+import { managed, setDefaultManagerForDoc } from './classes.collection.js';
+import { SmartDataDbDoc, svDb, unI } from './classes.doc.js';
+import { SmartdataDbWatcher } from './classes.watcher.js';
+import { logger } from './logging.js';
+let DistributedClass = (() => {
+    let _classDecorators = [managed()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SmartDataDbDoc;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
+    var DistributedClass = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _id_decorators = [unI()];
+            _data_decorators = [svDb()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _data_decorators, { kind: "field", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DistributedClass = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // INSTANCE
+        id = __runInitializers(this, _id_initializers, void 0);
+        data = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _data_initializers, void 0));
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _data_extraInitializers);
+        }
+    };
+    return DistributedClass = _classThis;
+})();
+export { DistributedClass };
+/**
+ * This file implements a distributed coordinator according to the @pushrocks/taskbuffer standard.
+ * you should not set up this yourself. Instead, there is a factory on the SmartdataDb class
+ * that will take care of setting this up.
+ */
+export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distributedCoordination
+    .AbstractDistributedCoordinator {
+    readyPromise;
+    db;
+    asyncExecutionStack = new plugins.lik.AsyncExecutionStack();
+    ownInstance;
+    distributedWatcher;
+    constructor(dbArg) {
+        super();
+        this.db = dbArg;
+        setDefaultManagerForDoc(this, DistributedClass);
+        this.readyPromise = this.db.statusConnectedDeferred.promise;
+    }
+    // smartdata specific stuff
+    async start() {
+        await this.init();
+    }
+    async stop() {
+        await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            if (this.distributedWatcher) {
+                await this.distributedWatcher.close();
+            }
+            if (this.ownInstance?.data.elected) {
+                this.ownInstance.data.elected = false;
+            }
+            if (this.ownInstance?.data.status === 'stopped') {
+                logger.log('warn', `stopping a distributed instance that has not been started yet.`);
+            }
+            this.ownInstance.data.status = 'stopped';
+            await this.ownInstance.save();
+            logger.log('info', `stopped ${this.ownInstance.id}`);
+        });
+    }
+    id = plugins.smartunique.uni('distributedInstance');
+    startHeartbeat = async () => {
+        while (this.ownInstance.data.status !== 'stopped') {
+            await this.sendHeartbeat();
+            await plugins.smartdelay.delayForRandom(5000, 10000);
+        }
+    };
+    async sendHeartbeat() {
+        await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            if (this.ownInstance.data.status === 'stopped') {
+                logger.log('debug', `aborted sending heartbeat because status is stopped`);
+                return;
+            }
+            await this.ownInstance.updateFromDb();
+            this.ownInstance.data.lastUpdated = Date.now();
+            await this.ownInstance.save();
+            logger.log('debug', `sent heartbeat for ${this.ownInstance.id}`);
+            const allInstances = DistributedClass.getInstances({});
+        });
+        if (this.ownInstance.data.status === 'stopped') {
+            logger.log('info', `aborted sending heartbeat because status is stopped`);
+            return;
+        }
+        const eligibleLeader = await this.getEligibleLeader();
+        // not awaiting here because we don't want to block the heartbeat
+        this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            if (!eligibleLeader && this.ownInstance.data.status === 'settled') {
+                this.checkAndMaybeLead();
+            }
+        });
+    }
+    async init() {
+        await this.readyPromise;
+        if (!this.ownInstance) {
+            await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+                this.ownInstance = new DistributedClass();
+                this.ownInstance.id = this.id;
+                this.ownInstance.data = {
+                    elected: false,
+                    lastUpdated: Date.now(),
+                    status: 'initializing',
+                    taskRequests: [],
+                    taskRequestResults: [],
+                };
+                await this.ownInstance.save();
+            });
+        }
+        else {
+            logger.log('warn', `distributed instance already initialized`);
+        }
+        // lets enable the heartbeat
+        this.startHeartbeat();
+        // lets do a leader check
+        await this.checkAndMaybeLead();
+        return this.ownInstance;
+    }
+    async getEligibleLeader() {
+        return this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            const allInstances = await DistributedClass.getInstances({});
+            let leaders = allInstances.filter((instanceArg) => instanceArg.data.elected === true);
+            const eligibleLeader = leaders.find((leader) => leader.data.lastUpdated >=
+                Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ seconds: 20 }));
+            return eligibleLeader;
+        });
+    }
+    // --> leader election
+    async checkAndMaybeLead() {
+        await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            this.ownInstance.data.status = 'initializing';
+            await this.ownInstance.save();
+        });
+        if (await this.getEligibleLeader()) {
+            await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+                await this.ownInstance.updateFromDb();
+                this.ownInstance.data.status = 'settled';
+                await this.ownInstance.save();
+                logger.log('info', `${this.ownInstance.id} settled as follower`);
+            });
+            return;
+        }
+        else if ((await DistributedClass.getInstances({})).find((instanceArg) => {
+            return instanceArg.data.status === 'bidding' &&
+                instanceArg.data.biddingStartTime <= Date.now() - 4000 &&
+                instanceArg.data.biddingStartTime >= Date.now() - 30000;
+        })) {
+            logger.log('info', 'too late to the bidding party... waiting for next round.');
+            return;
+        }
+        else {
+            await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+                await this.ownInstance.updateFromDb();
+                this.ownInstance.data.status = 'bidding';
+                this.ownInstance.data.biddingStartTime = Date.now();
+                this.ownInstance.data.biddingShortcode = plugins.smartunique.shortId();
+                await this.ownInstance.save();
+                logger.log('info', 'bidding code stored.');
+            });
+            logger.log('info', `bidding for leadership...`);
+            await plugins.smartdelay.delayFor(plugins.smarttime.getMilliSecondsFromUnits({ seconds: 5 }));
+            await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+                let biddingInstances = await DistributedClass.getInstances({});
+                biddingInstances = biddingInstances.filter((instanceArg) => instanceArg.data.status === 'bidding' &&
+                    instanceArg.data.lastUpdated >=
+                        Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ seconds: 10 }));
+                logger.log('info', `found ${biddingInstances.length} bidding instances...`);
+                this.ownInstance.data.elected = true;
+                for (const biddingInstance of biddingInstances) {
+                    if (biddingInstance.data.biddingShortcode < this.ownInstance.data.biddingShortcode) {
+                        this.ownInstance.data.elected = false;
+                    }
+                }
+                await plugins.smartdelay.delayFor(5000);
+                logger.log('info', `settling with status elected = ${this.ownInstance.data.elected}`);
+                this.ownInstance.data.status = 'settled';
+                await this.ownInstance.save();
+            });
+            if (this.ownInstance.data.elected) {
+                this.leadFunction();
+            }
+        }
+    }
+    /**
+     * when it has been determined
+     * that this instance is leading
+     * the leading is implemented here
+     */
+    async leadFunction() {
+        this.distributedWatcher = await DistributedClass.watch({});
+        const currentTaskRequests = [];
+        this.distributedWatcher.changeSubject.subscribe({
+            next: async (distributedDoc) => {
+                if (!distributedDoc) {
+                    logger.log('info', `registered deletion of instance...`);
+                    return;
+                }
+                logger.log('info', distributedDoc);
+                logger.log('info', `registered change for ${distributedDoc.id}`);
+                distributedDoc;
+            },
+        });
+        while (this.ownInstance.data.status !== 'stopped' && this.ownInstance.data.elected) {
+            const allInstances = await DistributedClass.getInstances({});
+            for (const instance of allInstances) {
+                if (instance.data.status === 'stopped') {
+                    await instance.delete();
+                }
+            }
+            await plugins.smartdelay.delayFor(10000);
+        }
+    }
+    // abstract implemented methods
+    async fireDistributedTaskRequest(taskRequestArg) {
+        await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            if (!this.ownInstance) {
+                logger.log('error', 'instance need to be started first...');
+                return;
+            }
+            await this.ownInstance.updateFromDb();
+            this.ownInstance.data.taskRequests.push(taskRequestArg);
+            await this.ownInstance.save();
+        });
+        await plugins.smartdelay.delayFor(10000);
+        const result = await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            await this.ownInstance.updateFromDb();
+            const taskRequestResult = this.ownInstance.data.taskRequestResults.find((resultItem) => {
+                return resultItem.requestResponseId === taskRequestArg.requestResponseId;
+            });
+            return taskRequestResult;
+        });
+        if (!result) {
+            logger.log('warn', 'no result found for task request...');
+            return null;
+        }
+        return result;
+    }
+    async updateDistributedTaskRequest(infoBasisArg) {
+        await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+            const existingInfoBasis = this.ownInstance.data.taskRequests.find((infoBasisItem) => {
+                return (infoBasisItem.taskName === infoBasisArg.taskName &&
+                    infoBasisItem.taskExecutionTime === infoBasisArg.taskExecutionTime);
+            });
+            if (!existingInfoBasis) {
+                logger.log('warn', 'trying to update a non existing task request... aborting!');
+                return;
+            }
+            Object.assign(existingInfoBasis, infoBasisArg);
+            await this.ownInstance.save();
+            plugins.smartdelay.delayFor(60000).then(() => {
+                this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+                    const indexToRemove = this.ownInstance.data.taskRequests.indexOf(existingInfoBasis);
+                    if (indexToRemove >= 0) {
+                        this.ownInstance.data.taskRequests.splice(indexToRemove, 1);
+                        await this.ownInstance.save();
+                    }
+                });
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.distributedcoordinator.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.distributedcoordinator.ts"],"names":[],"mappings":"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"}