document-drive 1.17.2 → 1.19.0

package/src/server/listener/manager.ts

@@ -6,20 +6,24 @@ import { OperationScope } from "document-model/document";
 import { logger } from "../../utils/logger";
 import { OperationError } from "../error";
 import {
-  BaseListenerManager,
+  DefaultListenerManagerOptions,
+  DriveUpdateErrorHandler,
   ErrorStatus,
   GetStrandsOptions,
+  IBaseDocumentDriveServer,
+  IListenerManager,
   Listener,
+  ListenerManagerOptions,
   ListenerState,
   ListenerUpdate,
   OperationUpdate,
   StrandUpdate,
   SynchronizationUnit,
+  SynchronizationUnitQuery,
 } from "../types";
-import { PullResponderTransmitter } from "./transmitter";
-import { InternalTransmitter } from "./transmitter/internal";
-import { SwitchboardPushTransmitter } from "./transmitter/switchboard-push";
-import { ITransmitter, StrandUpdateSource } from "./transmitter/types";
+import { StrandUpdateSource } from "./transmitter/types";
+
+const ENABLE_SYNC_DEBUG = false;
 
 function debounce<T extends unknown[], R>(
   func: (...args: T) => Promise<R>,
@@ -45,30 +49,81 @@ function debounce<T extends unknown[], R>(
     });
   };
 }
-export class ListenerManager extends BaseListenerManager {
+
+export class ListenerManager implements IListenerManager {
   static LISTENER_UPDATE_DELAY = 250;
+  private debugID = `[LM  #${Math.floor(Math.random() * 999)}]`;
+  protected driveServer: IBaseDocumentDriveServer;
+  protected options: ListenerManagerOptions;
+
+  // driveId -> listenerId -> listenerState
+  protected listenerStateByDriveId = new Map<
+    string,
+    Map<string, ListenerState>
+  >();
+
+  constructor(
+    drive: IBaseDocumentDriveServer,
+    listenerState = new Map<string, Map<string, ListenerState>>(),
+    options: ListenerManagerOptions = DefaultListenerManagerOptions,
+  ) {
+    this.debugLog(`constructor(...)`);
+    this.driveServer = drive;
+    this.listenerStateByDriveId = listenerState;
+    this.options = { ...DefaultListenerManagerOptions, ...options };
+  }
 
-  async getTransmitter(
-    driveId: string,
-    listenerId: string,
-  ): Promise<ITransmitter | undefined> {
-    return Promise.resolve(this.transmitters[driveId]?.[listenerId]);
+  private debugLog(...data: any[]) {
+    if (!ENABLE_SYNC_DEBUG) {
+      return;
+    }
+
+    if (data.length > 0 && typeof data[0] === "string") {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      console.log(`${this.debugID} ${data[0]}`, ...data.slice(1));
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      console.log(this.debugID, ...data);
+    }
+  }
+
+  async initialize(handler: DriveUpdateErrorHandler) {
+    this.debugLog("initialize(...)");
+    // if network connect comes back online
+    // then triggers the listeners update
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => {
+        this.triggerUpdate(false, { type: "local" }, handler).catch((error) => {
+          logger.error("Non handled error updating listeners", error);
+        });
+      });
+    }
   }
 
   driveHasListeners(driveId: string) {
-    return this.listenerState.has(driveId);
+    return this.listenerStateByDriveId.has(driveId);
   }
 
-  async addListener(listener: Listener) {
-    const drive = listener.driveId;
+  async setListener(driveId: string, listener: Listener) {
+    this.debugLog(
+      `setListener(drive: ${driveId}, listener: ${listener.listenerId})`,
+    );
 
-    if (!this.listenerState.has(drive)) {
-      this.listenerState.set(drive, new Map());
+    // slight code smell -- drive id may not need to be on listener or not passed in
+    if (driveId !== listener.driveId) {
+      throw new Error("Drive ID mismatch");
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const driveMap = this.listenerState.get(drive)!;
-    driveMap.set(listener.listenerId, {
+    let existingState;
+    try {
+      existingState = this.getListenerState(driveId, listener.listenerId);
+    } catch {
+      existingState = {};
+    }
+
+    // keep existing state if it exists
+    this.setListenerState(driveId, listener.listenerId, {
+      ...existingState,
       block: listener.block,
       driveId: listener.driveId,
       pendingTimeout: "0",
@@ -77,38 +132,13 @@ export class ListenerManager extends BaseListenerManager {
       syncUnits: new Map(),
     });
 
-    let transmitter: ITransmitter | undefined;
-
-    switch (listener.callInfo?.transmitterType) {
-      case "SwitchboardPush": {
-        transmitter = new SwitchboardPushTransmitter(listener, this.drive);
-        break;
-      }
-
-      case "PullResponder": {
-        transmitter = new PullResponderTransmitter(listener, this.drive, this);
-        break;
-      }
-      case "Internal": {
-        transmitter = new InternalTransmitter(listener, this.drive);
-        break;
-      }
-    }
-
-    if (!transmitter) {
-      throw new Error("Transmitter not found");
-    }
-
-    const driveTransmitters = this.transmitters[drive] || {};
-    driveTransmitters[listener.listenerId] = transmitter;
-    this.transmitters[drive] = driveTransmitters;
-
     this.triggerUpdate(true, { type: "local" });
-    return Promise.resolve(transmitter);
   }
 
   async removeListener(driveId: string, listenerId: string) {
-    const driveMap = this.listenerState.get(driveId);
+    this.debugLog("setListener()");
+
+    const driveMap = this.listenerStateByDriveId.get(driveId);
     if (!driveMap) {
       return false;
     }
@@ -119,8 +149,8 @@ export class ListenerManager extends BaseListenerManager {
   async removeSyncUnits(
     driveId: string,
     syncUnits: Pick<SynchronizationUnit, "syncId">[],
-  ) {
-    const listeners = this.listenerState.get(driveId);
+  ): Promise<void> {
+    const listeners = this.listenerStateByDriveId.get(driveId);
     if (!listeners) {
       return;
     }
@@ -140,38 +170,35 @@ export class ListenerManager extends BaseListenerManager {
     onError?: (error: Error, driveId: string, listener: ListenerState) => void,
     forceSync = false,
   ) {
-    const drive = this.listenerState.get(driveId);
-    if (!drive) {
+    const listenerIdToListenerState = this.listenerStateByDriveId.get(driveId);
+    if (!listenerIdToListenerState) {
       return [];
     }
 
     const outdatedListeners: Listener[] = [];
-    for (const [, listener] of drive) {
+    for (const [, listenerState] of listenerIdToListenerState) {
       if (
         outdatedListeners.find(
-          (l) => l.listenerId === listener.listener.listenerId,
+          (l) => l.listenerId === listenerState.listener.listenerId,
         )
       ) {
         continue;
       }
 
-      const transmitter = await this.getTransmitter(
-        driveId,
-        listener.listener.listenerId,
-      );
+      const transmitter = listenerState.listener.transmitter;
       if (!transmitter?.transmit) {
         continue;
       }
 
       for (const syncUnit of syncUnits) {
-        if (!this._checkFilter(listener.listener.filter, syncUnit)) {
+        if (!this._checkFilter(listenerState.listener.filter, syncUnit)) {
           continue;
         }
 
-        const listenerRev = listener.syncUnits.get(syncUnit.syncId);
+        const listenerRev = listenerState.syncUnits.get(syncUnit.syncId);
 
         if (!listenerRev || listenerRev.listenerRev < syncUnit.revision) {
-          outdatedListeners.push(listener.listener);
+          outdatedListeners.push(listenerState.listener);
           break;
         }
       }
@@ -190,7 +217,7 @@ export class ListenerManager extends BaseListenerManager {
     syncId: string,
     listenerRev: number,
   ): Promise<void> {
-    const drive = this.listenerState.get(driveId);
+    const drive = this.listenerStateByDriveId.get(driveId);
     if (!drive) {
       return;
     }
@@ -220,32 +247,51 @@ export class ListenerManager extends BaseListenerManager {
   private async _triggerUpdate(
     source: StrandUpdateSource,
     onError?: (error: Error, driveId: string, listener: ListenerState) => void,
+    maxContinues = 500,
   ) {
+    this.debugLog(
+      `_triggerUpdate(source: ${source.type}, maxContinues: ${maxContinues})`,
+      this.listenerStateByDriveId,
+    );
+
+    if (maxContinues < 0) {
+      throw new Error("Maximum retries exhausted.");
+    }
+
     const listenerUpdates: ListenerUpdate[] = [];
-    for (const [driveId, drive] of this.listenerState) {
-      for (const [id, listener] of drive) {
-        const transmitter = await this.getTransmitter(driveId, id);
+
+    for (const [driveId, drive] of this.listenerStateByDriveId) {
+      for (const [listenerId, listenerState] of drive) {
+        const transmitter = listenerState.listener.transmitter;
+
         if (!transmitter?.transmit) {
+          this.debugLog(`Transmitter not set on listener: ${listenerId}`);
           continue;
         }
 
-        const syncUnits = await this.getListenerSyncUnits(
-          driveId,
-          listener.listener.listenerId,
-        );
-
+        const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
         const strandUpdates: StrandUpdate[] = [];
+
+        this.debugLog("syncUnits", syncUnits);
+
         // TODO change to push one after the other, reusing operation data
         const tasks = syncUnits.map((syncUnit) => async () => {
-          const unitState = listener.syncUnits.get(syncUnit.syncId);
+          const unitState = listenerState.syncUnits.get(syncUnit.syncId);
 
           if (unitState && unitState.listenerRev >= syncUnit.revision) {
+            this.debugLog(
+              `Abandoning push for sync unit ${syncUnit.syncId}: already up-to-date (${unitState.listenerRev} >= ${syncUnit.revision})`,
+            );
             return;
+          } else {
+            this.debugLog(
+              `Listener out-of-date for sync unit ${syncUnit.syncId}: ${unitState?.listenerRev} < ${syncUnit.revision}`,
+            );
           }
 
           const opData: OperationUpdate[] = [];
           try {
-            const data = await this.drive.getOperationData(
+            const data = await this.driveServer.getOperationData(
               // TODO - join queries, DEAL WITH INVALID SYNC ID ERROR
               driveId,
               syncUnit.syncId,
@@ -259,6 +305,9 @@ export class ListenerManager extends BaseListenerManager {
           }
 
           if (!opData.length) {
+            this.debugLog(
+              `Abandoning push for ${syncUnit.syncId}: no operations found`,
+            );
             return;
           }
 
@@ -270,34 +319,53 @@ export class ListenerManager extends BaseListenerManager {
             scope: syncUnit.scope as OperationScope,
           });
         });
+
         if (this.options.sequentialUpdates) {
+          this.debugLog(
+            `Collecting ${tasks.length} syncUnit strandUpdates in sequence`,
+          );
           for (const task of tasks) {
             await task();
           }
         } else {
+          this.debugLog(
+            `Collecting ${tasks.length} syncUnit strandUpdates in parallel`,
+          );
           await Promise.all(tasks.map((task) => task()));
         }
 
         if (strandUpdates.length == 0) {
+          this.debugLog(`No strandUpdates needed for listener ${listenerId}`);
           continue;
         }
 
-        listener.pendingTimeout = new Date(
+        listenerState.pendingTimeout = new Date(
           new Date().getTime() / 1000 + 300,
         ).toISOString();
-        listener.listenerStatus = "PENDING";
+
+        listenerState.listenerStatus = "PENDING";
 
         // TODO update listeners in parallel, blocking for listeners with block=true
         try {
+          this.debugLog(
+            `_triggerUpdate(source: ${source.type}) > transmitter.transmit`,
+          );
+
           const listenerRevisions = await transmitter.transmit(
             strandUpdates,
             source,
           );
 
-          listener.pendingTimeout = "0";
-          listener.listenerStatus = "PENDING";
+          this.debugLog(
+            `_triggerUpdate(source: ${source.type}) > transmission succeeded`,
+            listenerRevisions,
+          );
+
+          listenerState.pendingTimeout = "0";
+          listenerState.listenerStatus = "PENDING";
 
           const lastUpdated = new Date().toISOString();
+          let continuationNeeded = false;
 
           for (const revision of listenerRevisions) {
             const syncUnit = syncUnits.find(
@@ -306,14 +374,45 @@ export class ListenerManager extends BaseListenerManager {
                 revision.scope === unit.scope &&
                 revision.branch === unit.branch,
             );
+
             if (syncUnit) {
-              listener.syncUnits.set(syncUnit.syncId, {
+              listenerState.syncUnits.set(syncUnit.syncId, {
                 lastUpdated,
                 listenerRev: revision.revision,
               });
+
+              // Check for revision status vv
+              const su = strandUpdates.find(
+                (su) =>
+                  su.driveId === revision.driveId &&
+                  su.documentId === revision.documentId &&
+                  su.scope === revision.scope &&
+                  su.branch === revision.branch,
+              );
+
+              if (su && su.operations.length > 0) {
+                const suIndex = su.operations.at(
+                  su.operations.length - 1,
+                )?.index;
+                if (suIndex !== revision.revision) {
+                  this.debugLog(
+                    `Revision still out-of-date for ${su.documentId}:${su.scope}:${su.branch} ${suIndex} <> ${revision.revision}`,
+                  );
+                  continuationNeeded = true;
+                } else {
+                  this.debugLog(
+                    `Revision match for ${su.documentId}:${su.scope}:${su.branch} ${suIndex}`,
+                  );
+                }
+              } else {
+                this.debugLog(
+                  `Cannot find strand update for (${revision.documentId}:${revision.scope}:${revision.branch} in drive ${revision.driveId})`,
+                );
+              }
+              // Check for revision status ^^
             } else {
               logger.warn(
-                `Received revision for untracked unit for listener ${listener.listener.listenerId}`,
+                `Received revision for untracked unit for listener ${listenerState.listener.listenerId}`,
                 revision,
               );
             }
@@ -322,32 +421,46 @@ export class ListenerManager extends BaseListenerManager {
           for (const revision of listenerRevisions) {
             const error = revision.status === "ERROR";
             if (revision.error?.includes("Missing operations")) {
-              const updates = await this._triggerUpdate(source, onError);
-              listenerUpdates.push(...updates);
-            } else {
-              listenerUpdates.push({
-                listenerId: listener.listener.listenerId,
-                listenerRevisions,
-              });
-              if (error) {
-                throw new OperationError(
-                  revision.status as ErrorStatus,
-                  undefined,
-                  revision.error,
-                  revision.error,
-                );
-              }
+              continuationNeeded = true;
+            } else if (error) {
+              throw new OperationError(
+                revision.status as ErrorStatus,
+                undefined,
+                revision.error,
+                revision.error,
+              );
             }
           }
-          listener.listenerStatus = "SUCCESS";
+
+          if (!continuationNeeded) {
+            listenerUpdates.push({
+              listenerId: listenerState.listener.listenerId,
+              listenerRevisions,
+            });
+          } else {
+            const updates = await this._triggerUpdate(
+              source,
+              onError,
+              maxContinues - 1,
+            );
+            listenerUpdates.push(...updates);
+          }
+
+          listenerState.listenerStatus = "SUCCESS";
         } catch (e) {
           // TODO: Handle error based on listener params (blocking, retry, etc)
-          onError?.(e as Error, driveId, listener);
-          listener.listenerStatus =
+          onError?.(e as Error, driveId, listenerState);
+          listenerState.listenerStatus =
             e instanceof OperationError ? e.status : "ERROR";
         }
       }
     }
+
+    this.debugLog(
+      `Returning listener updates (maxContinues: ${maxContinues})`,
+      listenerUpdates,
+    );
+
     return listenerUpdates;
   }
 
@@ -378,12 +491,12 @@ export class ListenerManager extends BaseListenerManager {
     listenerId: string,
     loadedDrive?: DocumentDriveDocument,
   ) {
-    const listener = this.listenerState.get(driveId)?.get(listenerId);
+    const listener = this.listenerStateByDriveId.get(driveId)?.get(listenerId);
     if (!listener) {
       return [];
     }
     const filter = listener.listener.filter;
-    return this.drive.getSynchronizationUnits(
+    return this.driveServer.getSynchronizationUnits(
       driveId,
       filter.documentId ?? ["*"],
       filter.scope ?? ["*"],
@@ -393,13 +506,16 @@ export class ListenerManager extends BaseListenerManager {
     );
   }
 
-  getListenerSyncUnitIds(driveId: string, listenerId: string) {
-    const listener = this.listenerState.get(driveId)?.get(listenerId);
+  getListenerSyncUnitIds(
+    driveId: string,
+    listenerId: string,
+  ): Promise<SynchronizationUnitQuery[]> {
+    const listener = this.listenerStateByDriveId.get(driveId)?.get(listenerId);
     if (!listener) {
-      return [];
+      return Promise.resolve([]);
     }
     const filter = listener.listener.filter;
-    return this.drive.getSynchronizationUnitsIds(
+    return this.driveServer.getSynchronizationUnitsIds(
       driveId,
       filter.documentId ?? ["*"],
       filter.scope ?? ["*"],
@@ -408,47 +524,23 @@ export class ListenerManager extends BaseListenerManager {
     );
   }
 
-  async initDrive(drive: DocumentDriveDocument) {
-    const {
-      state: {
-        local: { listeners },
-      },
-    } = drive;
-
-    for (const listener of listeners) {
-      await this.addListener({
-        block: listener.block,
-        driveId: drive.state.global.id,
-        filter: {
-          branch: listener.filter.branch ?? [],
-          documentId: listener.filter.documentId ?? [],
-          documentType: listener.filter.documentType,
-          scope: listener.filter.scope ?? [],
-        },
-        listenerId: listener.listenerId,
-        system: listener.system,
-        callInfo: listener.callInfo ?? undefined,
-        label: listener.label ?? "",
-      });
-    }
-  }
-
   async removeDrive(driveId: string): Promise<void> {
-    this.listenerState.delete(driveId);
-    const transmitters = this.transmitters[driveId];
-    if (transmitters) {
-      await Promise.all(
-        Object.values(transmitters).map((t) => t.disconnect?.()),
-      );
+    const listenerIdToListenerState = this.listenerStateByDriveId.get(driveId);
+    if (!listenerIdToListenerState) {
+      return;
     }
-  }
 
-  getListener(driveId: string, listenerId: string): Promise<ListenerState> {
-    const drive = this.listenerState.get(driveId);
-    if (!drive) throw new Error("Drive not found");
-    const listener = drive.get(listenerId);
-    if (!listener) throw new Error("Listener not found");
-    return Promise.resolve(listener);
+    // delete first
+    this.listenerStateByDriveId.delete(driveId);
+
+    for (const [_, listenerState] of listenerIdToListenerState) {
+      // guarantee that all disconnects are called
+      try {
+        await listenerState.listener.transmitter?.disconnect?.();
+      } catch (error) {
+        logger.error(error);
+      }
+    }
   }
 
   async getStrands(
@@ -456,13 +548,13 @@ export class ListenerManager extends BaseListenerManager {
     listenerId: string,
     options?: GetStrandsOptions,
   ): Promise<StrandUpdate[]> {
-    // fetch listenerState from listenerManager
-    const listener = await this.getListener(driveId, listenerId);
+    // this will throw if listenerState is not found
+    const listenerState = this.getListenerState(driveId, listenerId);
 
     // fetch operations from drive  and prepare strands
     const strands: StrandUpdate[] = [];
 
-    const drive = await this.drive.getDrive(driveId);
+    const drive = await this.driveServer.getDrive(driveId);
     const syncUnits = await this.getListenerSyncUnits(
       driveId,
       listenerId,
@@ -480,14 +572,14 @@ export class ListenerManager extends BaseListenerManager {
       if (syncUnit.revision < 0) {
         return;
       }
-      const entry = listener.syncUnits.get(syncUnit.syncId);
+      const entry = listenerState.syncUnits.get(syncUnit.syncId);
       if (entry && entry.listenerRev >= syncUnit.revision) {
         return;
       }
 
       const { documentId, driveId, scope, branch } = syncUnit;
       try {
-        const operations = await this.drive.getOperationData(
+        const operations = await this.driveServer.getOperationData(
           // DEAL WITH INVALID SYNC ID ERROR
           driveId,
           syncUnit.syncId,
@@ -528,4 +620,33 @@ export class ListenerManager extends BaseListenerManager {
 
     return strands;
   }
+
+  getListenerState(driveId: string, listenerId: string) {
+    let listenerStateByListenerId = this.listenerStateByDriveId.get(driveId);
+    if (!listenerStateByListenerId) {
+      listenerStateByListenerId = new Map();
+      this.listenerStateByDriveId.set(driveId, listenerStateByListenerId);
+    }
+
+    const listenerState = listenerStateByListenerId.get(listenerId);
+    if (!listenerState) {
+      throw new Error("Listener not found");
+    }
+
+    return listenerState;
+  }
+
+  setListenerState(
+    driveId: string,
+    listenerId: string,
+    listenerState: ListenerState,
+  ) {
+    let listenerStateByListenerId = this.listenerStateByDriveId.get(driveId);
+    if (!listenerStateByListenerId) {
+      listenerStateByListenerId = new Map();
+      this.listenerStateByDriveId.set(driveId, listenerStateByListenerId);
+    }
+
+    listenerStateByListenerId.set(listenerId, listenerState);
+  }
 }