@mtcute/core 0.7.2 → 0.8.0

package/esm/highlevel/updates/manager.js

@@ -53,6 +53,7 @@ import { createDummyUpdatesContainer, extractChannelIdFromUpdate, isMessageEmpty
 //     return state.rpsProcessing.getRps()
 // }
 const KEEP_ALIVE_INTERVAL = 15 * 60 * 1000; // 15 minutes
+const UPDATES_TOO_LONG = { _: 'updatesTooLong' };
 // todo: fix docs
 export class UpdatesManager {
     constructor(client, params = {}) {
@@ -75,9 +76,8 @@ export class UpdatesManager {
         this.noDispatchPts = new Map();
         this.noDispatchQts = new Set();
         this.lock = new AsyncLock();
-        this.selfChanged = false; // todo what is this?
         // whether to catch up channels from the locally stored pts
-        this.catchUpChannels = false;
+        this.catchingUp = false;
         this.catchUpOnStart = this.params.catchUp ?? false;
         this.cpts = new Map();
         this.cptsMod = new Map();
@@ -85,6 +85,7 @@ export class UpdatesManager {
         this.channelsOpened = new Map();
         this.log = this.client.log.create('updates');
         this._handler = () => { };
+        this._onCatchingUp = () => { };
         if (client.params.disableUpdates) {
             throw new MtArgumentError('Updates must be enabled to use updates manager');
         }
@@ -97,14 +98,15 @@ export class UpdatesManager {
     setHandler(handler) {
         this._handler = handler;
     }
+    onCatchingUp(handler) {
+        this._onCatchingUp = handler;
+    }
     destroy() {
         this.stopLoop();
     }
     notifyLoggedIn(self) {
         this.auth = self;
-        this._fetchUpdatesState()
-            .then(() => this.startLoop())
-            .catch((err) => this.client.emitError(err));
+        this.startLoop().catch((err) => this.client.emitError(err));
     }
     notifyLoggedOut() {
         this.stopLoop();
@@ -117,7 +119,7 @@ export class UpdatesManager {
     }
     _onKeepAlive() {
         this.log.debug('no updates for >15 minutes, catching up');
-        this.handleUpdate({ _: 'updatesTooLong' });
+        this.handleUpdate(UPDATES_TOO_LONG);
     }
     /**
      * Start updates loop.
@@ -129,6 +131,7 @@ export class UpdatesManager {
      *
      * > **Note**: If you are using {@link UpdatesManagerParams.catchUp} option,
      * > catching up will be done in background, you can't await it.
+     * > Instead, listen for the `updating` and `connected` connection state events.
      */
     async startLoop() {
         if (this.updatesLoopActive)
@@ -139,6 +142,7 @@ export class UpdatesManager {
         }
         // start updates loop in background
         this.updatesLoopActive = true;
+        clearInterval(this.keepAliveInterval);
         this.keepAliveInterval = setInterval(this._onKeepAlive, KEEP_ALIVE_INTERVAL);
         this._loop().catch((err) => this.client.emitError(err));
         if (this.catchUpOnStart) {
@@ -171,15 +175,20 @@ export class UpdatesManager {
     }
     /**
      * Catch up with the server by loading missed updates.
-     *
+     *.
      * > **Note**: In case the storage was not properly
      * > closed the last time, "catching up" might
      * > result in duplicate updates.
      */
     catchUp() {
+        if (!this.updatesLoopActive) {
+            this.log.warn('catch up requested, but updates loop is not active, ignoring');
+            return;
+        }
         this.log.debug('catch up requested');
-        this.catchUpChannels = true;
-        this.handleUpdate({ _: 'updatesTooLong' });
+        this._onCatchingUp(true);
+        this.catchingUp = true;
+        this.handleUpdate(UPDATES_TOO_LONG);
     }
     handleClientUpdate(update, noDispatch = true) {
         if (noDispatch && this.noDispatchEnabled) {
@@ -617,7 +626,7 @@ export class UpdatesManager {
             channelDiffTimeouts.delete(channelId);
         }
         let _pts = cpts.get(channelId);
-        if (!_pts && this.catchUpChannels) {
+        if (!_pts && this.catchingUp) {
             _pts = await client.storage.updates.getChannelPts(channelId);
         }
         if (!_pts)
@@ -722,59 +731,59 @@ export class UpdatesManager {
     }
     async _fetchDifference(requestedDiff) {
         const { client, log, pendingPtsUpdates, pendingUnorderedUpdates } = this;
-        for (;;) {
-            const diff = await client.call({
-                _: 'updates.getDifference',
-                pts: this.pts,
-                date: this.date,
-                qts: this.qts,
-            });
-            switch (diff._) {
-                case 'updates.differenceEmpty':
-                    log.debug('updates.getDifference returned updates.differenceEmpty');
-                    return;
-                case 'updates.differenceTooLong':
-                    this.pts = diff.pts;
-                    log.debug('updates.getDifference returned updates.differenceTooLong');
-                    return;
+        const diff = await client.call({
+            _: 'updates.getDifference',
+            pts: this.pts,
+            date: this.date,
+            qts: this.qts,
+        });
+        switch (diff._) {
+            case 'updates.differenceEmpty':
+                log.debug('updates.getDifference returned updates.differenceEmpty');
+                return;
+            case 'updates.differenceTooLong':
+                this.pts = diff.pts;
+                log.debug('updates.getDifference returned updates.differenceTooLong');
+                return;
+        }
+        const fetchedState = diff._ === 'updates.difference' ? diff.state : diff.intermediateState;
+        log.debug('updates.getDifference returned %d messages, %d updates. new pts: %d, qts: %d, seq: %d, final: %b', diff.newMessages.length, diff.otherUpdates.length, fetchedState.pts, fetchedState.qts, fetchedState.seq, diff._ === 'updates.difference');
+        const peers = PeersIndex.from(diff);
+        diff.newMessages.forEach((message) => {
+            log.debug('processing message %d in %j (%s) from common diff', message.id, message.peerId, message._);
+            if (message._ === 'messageEmpty')
+                return;
+            // pts does not need to be checked for them
+            pendingUnorderedUpdates.pushBack(toPendingUpdate(messageToUpdate(message), peers, true));
+        });
+        diff.otherUpdates.forEach((upd) => {
+            if (upd._ === 'updateChannelTooLong') {
+                log.debug('received updateChannelTooLong for channel %d in common diff (pts = %d), fetching diff', upd.channelId, upd.pts);
+                this._fetchChannelDifferenceLater(requestedDiff, upd.channelId, upd.pts);
+                return;
             }
-            const fetchedState = diff._ === 'updates.difference' ? diff.state : diff.intermediateState;
-            log.debug('updates.getDifference returned %d messages, %d updates. new pts: %d, qts: %d, seq: %d, final: %b', diff.newMessages.length, diff.otherUpdates.length, fetchedState.pts, fetchedState.qts, fetchedState.seq, diff._ === 'updates.difference');
-            const peers = PeersIndex.from(diff);
-            diff.newMessages.forEach((message) => {
-                log.debug('processing message %d in %j (%s) from common diff', message.id, message.peerId, message._);
-                if (message._ === 'messageEmpty')
-                    return;
-                // pts does not need to be checked for them
-                pendingUnorderedUpdates.pushBack(toPendingUpdate(messageToUpdate(message), peers, true));
-            });
-            diff.otherUpdates.forEach((upd) => {
-                if (upd._ === 'updateChannelTooLong') {
-                    log.debug('received updateChannelTooLong for channel %d in common diff (pts = %d), fetching diff', upd.channelId, upd.pts);
-                    this._fetchChannelDifferenceLater(requestedDiff, upd.channelId, upd.pts);
-                    return;
-                }
-                if (isMessageEmpty(upd))
-                    return;
-                const parsed = toPendingUpdate(upd, peers, true);
-                if (parsed.channelId && parsed.ptsBefore) {
-                    // we need to check pts for these updates, put into pts queue
-                    pendingPtsUpdates.add(parsed);
-                }
-                else {
-                    // the updates are in order already, we can treat them as unordered
-                    pendingUnorderedUpdates.pushBack(parsed);
-                }
-                log.debug('received %s from common diff, cid: %d, pts_before: %d, pts: %d, qts_before: %d', upd._, parsed.channelId, parsed.ptsBefore, parsed.pts, parsed.qtsBefore);
-            });
-            this.pts = fetchedState.pts;
-            this.qts = fetchedState.qts;
-            this.seq = fetchedState.seq;
-            this.date = fetchedState.date;
-            if (diff._ === 'updates.difference') {
+            if (isMessageEmpty(upd))
                 return;
+            const parsed = toPendingUpdate(upd, peers, true);
+            if (parsed.channelId && parsed.ptsBefore) {
+                // we need to check pts for these updates, put into pts queue
+                pendingPtsUpdates.add(parsed);
             }
+            else {
+                // the updates are in order already, we can treat them as unordered
+                pendingUnorderedUpdates.pushBack(parsed);
+            }
+            log.debug('received %s from common diff, cid: %d, pts_before: %d, pts: %d, qts_before: %d', upd._, parsed.channelId, parsed.ptsBefore, parsed.pts, parsed.qtsBefore);
+        });
+        this.pts = fetchedState.pts;
+        this.qts = fetchedState.qts;
+        this.seq = fetchedState.seq;
+        this.date = fetchedState.date;
+        if (diff._ === 'updates.difference') {
+            return;
         }
+        // fetch the next chunk in next tick
+        this.handleUpdate(UPDATES_TOO_LONG);
     }
     _fetchDifferenceLater(requestedDiff) {
         if (!requestedDiff.has(0)) {
@@ -947,13 +956,19 @@ export class UpdatesManager {
                     pendingQtsUpdates.length ||
                     pendingUnorderedUpdates.length ||
                     this.hasTimedoutPostponed)) {
+                    if (this.catchingUp) {
+                        // consider catching up completed if there are no more updates
+                        this.log.debug('catching up completed');
+                        this.catchingUp = false;
+                        this._onCatchingUp(false);
+                    }
                     await updatesLoopCv.wait();
                 }
                 if (!this.updatesLoopActive)
                     break;
                 log.debug('updates loop tick. pending containers: %d, pts: %d, pts_postponed: %d, qts: %d, qts_postponed: %d, unordered: %d', pendingUpdateContainers.length, pendingPtsUpdates.length, pendingPtsUpdatesPostponed.length, pendingQtsUpdates.length, pendingQtsUpdatesPostponed.length, pendingUnorderedUpdates.length);
                 const requestedDiff = new Map();
-                // first process pending containers
+                this.log.debug('processing pending containers');
                 while (pendingUpdateContainers.length) {
                     const { upd, seqStart, seqEnd } = pendingUpdateContainers.popFront();
                     switch (upd._) {
@@ -1123,7 +1138,7 @@ export class UpdatesManager {
                             assertNever(upd);
                     }
                 }
-                // process pts-ordered updates
+                this.log.debug('processing pending pts-ordered updates');
                 while (pendingPtsUpdates.length) {
                     const pending = pendingPtsUpdates.popFront();
                     const upd = pending.update;
@@ -1134,7 +1149,7 @@ export class UpdatesManager {
                     else if (cpts.has(pending.channelId)) {
                         localPts = cpts.get(pending.channelId);
                     }
-                    else if (this.catchUpChannels) {
+                    else if (this.catchingUp) {
                         // only load stored channel pts in case
                         // the user has enabled catching up.
                         // not loading stored pts effectively disables
@@ -1193,7 +1208,7 @@ export class UpdatesManager {
                     }
                     await this._onUpdate(pending, requestedDiff);
                 }
-                // process postponed pts-ordered updates
+                this.log.debug('processing postponed pts-ordered updates');
                 for (let item = pendingPtsUpdatesPostponed._first; item; item = item.n) {
                     // awesome fucking iteration because i'm so fucking tired and wanna kms
                     const pending = item.v;
@@ -1239,7 +1254,7 @@ export class UpdatesManager {
                     await this._onUpdate(pending, requestedDiff, true);
                     pendingPtsUpdatesPostponed._remove(item);
                 }
-                // process qts-ordered updates
+                this.log.debug('processing pending qts-ordered updates');
                 while (pendingQtsUpdates.length) {
                     const pending = pendingQtsUpdates.popFront();
                     const upd = pending.update;
@@ -1272,7 +1287,7 @@ export class UpdatesManager {
                     }
                     await this._onUpdate(pending, requestedDiff);
                 }
-                // process postponed qts-ordered updates
+                this.log.debug('processing postponed qts-ordered updates');
                 for (let item = pendingQtsUpdatesPostponed._first; item; item = item.n) {
                     // awesome fucking iteration because i'm so fucking tired and wanna kms
                     const pending = item.v;
@@ -1303,14 +1318,13 @@ export class UpdatesManager {
                     pendingQtsUpdatesPostponed._remove(item);
                 }
                 this.hasTimedoutPostponed = false;
-                // wait for all pending diffs to load
                 while (requestedDiff.size) {
                     log.debug('waiting for %d pending diffs before processing unordered: %J', requestedDiff.size, requestedDiff.keys());
                     await Promise.all([...requestedDiff.values()]);
                     // diff results may as well contain new diffs to be requested
                     log.debug('pending diffs awaited, new diffs requested: %d (%J)', requestedDiff.size, requestedDiff.keys());
                 }
-                // process unordered updates (or updates received from diff)
+                this.log.debug('processing pending unordered updates');
                 while (pendingUnorderedUpdates.length) {
                     const pending = pendingUnorderedUpdates.popFront();
                     await this._onUpdate(pending, requestedDiff, false, true);