kubernetes-fluent-client 2.5.1 → 2.6.1

package/dist/fluent/watch.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventEmitter } from "events";
 import { GenericClass } from "../types";
 import { Filters, WatchAction } from "./types";
@@ -16,35 +17,32 @@ export declare enum WatchEvent {
     GIVE_UP = "give_up",
     /** Abort is called */
     ABORT = "abort",
-    /** Resync is called */
-    RESYNC = "resync",
     /** Data is received and decoded */
     DATA = "data",
-    /** Bookmark is received */
-    BOOKMARK = "bookmark",
-    /** ResourceVersion is updated */
-    RESOURCE_VERSION = "resource_version",
     /** 410 (old resource version) occurs */
     OLD_RESOURCE_VERSION = "old_resource_version",
     /** A reconnect is already pending */
-    RECONNECT_PENDING = "reconnect_pending"
+    RECONNECT_PENDING = "reconnect_pending",
+    /** Resource list operation run */
+    LIST = "list",
+    /** List operation error */
+    LIST_ERROR = "list_error"
 }
 /** Configuration for the watch function. */
 export type WatchCfg = {
-    /** Whether to allow watch bookmarks. */
-    allowWatchBookmarks?: boolean;
-    /** The resource version to start the watch at, this will be updated on each event. */
-    resourceVersion?: string;
     /** The maximum number of times to retry the watch, the retry count is reset on success. Unlimited retries if not specified. */
     retryMax?: number;
-    /** The delay between retries in seconds. Defaults to 10 seconds. */
+    /** Seconds between each retry check. Defaults to 5. */
     retryDelaySec?: number;
+    /** Amount of seconds to wait before relisting the watch list. Defaults to 600 (10 minutes). */
+    relistIntervalSec?: number;
     /** Amount of seconds to wait before a forced-resyncing of the watch list. Defaults to 300 (5 minutes). */
     resyncIntervalSec?: number;
 };
 /** A wrapper around the Kubernetes watch API. */
 export declare class Watcher<T extends GenericClass> {
     #private;
+    $relistTimer?: NodeJS.Timeout;
     /**
      * Setup a Kubernetes watcher for the specified model and filters. The callback function will be called for each event received.
      * The watch can be aborted by calling {@link Watcher.close} or by calling abort() on the AbortController returned by {@link Watcher.start}.
@@ -73,18 +71,6 @@ export declare class Watcher<T extends GenericClass> {
      * @returns the watch CacheID
      */
     getCacheID(): string;
-    /**
-     * Get the current resource version.
-     *
-     * @returns the current resource version
-     */
-    get resourceVersion(): string | undefined;
-    /**
-     * Set the current resource version.
-     *
-     * @param resourceVersion - the new resource version
-     */
-    set resourceVersion(resourceVersion: string | undefined);
     /**
      * Subscribe to watch events. This is an EventEmitter that emits the following events:
      *

package/dist/fluent/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.ts"],"names":[],"mappings":";;AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAG3D,oBAAY,UAAU;IACpB,sCAAsC;IACtC,OAAO,YAAY;IACnB,2BAA2B;IAC3B,aAAa,kBAAkB;IAC/B,kDAAkD;IAClD,UAAU,eAAe;IACzB,0BAA0B;IAC1B,SAAS,cAAc;IACvB,8BAA8B;IAC9B,OAAO,YAAY;IACnB,sBAAsB;IACtB,KAAK,UAAU;IACf,uBAAuB;IACvB,MAAM,WAAW;IACjB,mCAAmC;IACnC,IAAI,SAAS;IACb,2BAA2B;IAC3B,QAAQ,aAAa;IACrB,iCAAiC;IACjC,gBAAgB,qBAAqB;IACrC,wCAAwC;IACxC,oBAAoB,yBAAyB;IAC7C,qCAAqC;IACrC,iBAAiB,sBAAsB;CACxC;AAED,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG;IACrB,wCAAwC;IACxC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,sFAAsF;IACtF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+HAA+H;IAC/H,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0GAA0G;IAC1G,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,iDAAiD;AACjD,qBAAa,OAAO,CAAC,CAAC,SAAS,YAAY;;IAyBzC;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,QAAa;IAiBzF;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAK9C,gGAAgG;IACzF,KAAK;IAMZ;;;;;OAKG;IACI,UAAU;IAWjB;;;;OAIG;IACH,IAAW,eAAe,IASkB,MAAM,GAAG,SAAS,CAP7D;IAED;;;;OAIG;IACH,IAAW,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,EAE7D;IAED;;;;;;OAMG;IACH,IAAW,MAAM,IAAI,YAAY,CAEhC;CAwOF"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.ts"],"names":[],"mappings":";;;AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC,OAAO,EAAE,YAAY,EAAwB,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAG3D,oBAAY,UAAU;IACpB,sCAAsC;IACtC,OAAO,YAAY;IACnB,2BAA2B;IAC3B,aAAa,kBAAkB;IAC/B,kDAAkD;IAClD,UAAU,eAAe;IACzB,0BAA0B;IAC1B,SAAS,cAAc;IACvB,8BAA8B;IAC9B,OAAO,YAAY;IACnB,sBAAsB;IACtB,KAAK,UAAU;IACf,mCAAmC;IACnC,IAAI,SAAS;IACb,wCAAwC;IACxC,oBAAoB,yBAAyB;IAC7C,qCAAqC;IACrC,iBAAiB,sBAAsB;IACvC,kCAAkC;IAClC,IAAI,SAAS;IACb,2BAA2B;IAC3B,UAAU,eAAe;CAC1B;AAED,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG;IACrB,+HAA+H;IAC/H,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,0GAA0G;IAC1G,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAKF,iDAAiD;AACjD,qBAAa,OAAO,CAAC,CAAC,SAAS,YAAY;;IAwBzC,YAAY,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAc9B;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,QAAa;IAgCzF;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAK9C,gGAAgG;IACzF,KAAK;IAOZ;;;;;OAKG;IACI,UAAU;IAWjB;;;;;;OAMG;IACH,IAAW,MAAM,IAAI,YAAY,CAEhC;CAyTF"}

package/dist/fluent/watch.js

@@ -10,6 +10,7 @@ const byline_1 = __importDefault(require("byline"));
 const crypto_1 = require("crypto");
 const events_1 = require("events");
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const fetch_1 = require("../fetch");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
 var WatchEvent;
@@ -26,19 +27,19 @@ var WatchEvent;
     WatchEvent["GIVE_UP"] = "give_up";
     /** Abort is called */
     WatchEvent["ABORT"] = "abort";
-    /** Resync is called */
-    WatchEvent["RESYNC"] = "resync";
     /** Data is received and decoded */
     WatchEvent["DATA"] = "data";
-    /** Bookmark is received */
-    WatchEvent["BOOKMARK"] = "bookmark";
-    /** ResourceVersion is updated */
-    WatchEvent["RESOURCE_VERSION"] = "resource_version";
     /** 410 (old resource version) occurs */
     WatchEvent["OLD_RESOURCE_VERSION"] = "old_resource_version";
     /** A reconnect is already pending */
     WatchEvent["RECONNECT_PENDING"] = "reconnect_pending";
+    /** Resource list operation run */
+    WatchEvent["LIST"] = "list";
+    /** List operation error */
+    WatchEvent["LIST_ERROR"] = "list_error";
 })(WatchEvent || (exports.WatchEvent = WatchEvent = {}));
+const NONE = 50;
+const OVERRIDE = 100;
 /** A wrapper around the Kubernetes watch API. */
 class Watcher {
     // User-provided properties
@@ -46,6 +47,9 @@ class Watcher {
     #filters;
     #callback;
     #watchCfg;
+    // Track the last time data was received
+    #lastSeenTime = NONE;
+    #lastSeenLimit;
     // Create a wrapped AbortController to allow the watch to be aborted externally
     #abortController;
     // Track the number of retries
@@ -54,10 +58,16 @@ class Watcher {
     #stream;
     // Create an EventEmitter to emit events
     #events = new events_1.EventEmitter();
+    // Create a timer to relist the watch
+    $relistTimer;
     // Create a timer to resync the watch
     #resyncTimer;
     // Track if a reconnect is pending
     #pendingReconnect = false;
+    // The resource version to start the watch at, this will be updated after the list operation.
+    #resourceVersion;
+    // Track the list of items in the cache
+    #cache = new Map();
     /**
      * Setup a Kubernetes watcher for the specified model and filters. The callback function will be called for each event received.
      * The watch can be aborted by calling {@link Watcher.close} or by calling abort() on the AbortController returned by {@link Watcher.start}.
@@ -71,10 +81,20 @@ class Watcher {
      * @param watchCfg - (optional) watch configuration
      */
     constructor(model, filters, callback, watchCfg = {}) {
-        // Set the retry delay to 10 seconds if not specified
-        watchCfg.retryDelaySec ??= 10;
-        // Set the resync interval to 5 minutes if not specified
-        watchCfg.resyncIntervalSec ??= 300;
+        // Set the retry delay to 5 seconds if not specified
+        watchCfg.retryDelaySec ??= 5;
+        // Set the relist interval to 30 minutes if not specified
+        watchCfg.relistIntervalSec ??= 1800;
+        // Set the resync interval to 10 minutes if not specified
+        watchCfg.resyncIntervalSec ??= 600;
+        // Set the last seen limit to the resync interval
+        this.#lastSeenLimit = watchCfg.resyncIntervalSec * 1000;
+        // Add random jitter to the relist/resync intervals (up to 1 second)
+        const jitter = Math.floor(Math.random() * 1000);
+        // Check every relist interval for cache staleness
+        this.$relistTimer = setInterval(this.#list, watchCfg.relistIntervalSec * 1000 + jitter);
+        // Rebuild the watch every retry delay interval
+        this.#resyncTimer = setInterval(this.#checkResync, watchCfg.retryDelaySec * 1000 + jitter);
         // Bind class properties
         this.#model = model;
         this.#filters = filters;
@@ -89,13 +109,14 @@ class Watcher {
      * @returns The AbortController for the watch.
      */
     async start() {
-        await this.#runner();
+        await this.#watch();
         return this.#abortController;
     }
     /** Close the watch. Also available on the AbortController returned by {@link Watcher.start}. */
     close() {
-        clearTimeout(this.#resyncTimer);
-        this.#cleanup();
+        clearInterval(this.$relistTimer);
+        clearInterval(this.#resyncTimer);
+        this.#streamCleanup();
         this.#abortController.abort();
     }
     /**
@@ -113,22 +134,6 @@ class Watcher {
             .digest("hex")
             .substring(0, 10);
     }
-    /**
-     * Get the current resource version.
-     *
-     * @returns the current resource version
-     */
-    get resourceVersion() {
-        return this.#watchCfg.resourceVersion;
-    }
-    /**
-     * Set the current resource version.
-     *
-     * @param resourceVersion - the new resource version
-     */
-    set resourceVersion(resourceVersion) {
-        this.#watchCfg.resourceVersion = resourceVersion;
-    }
     /**
      * Subscribe to watch events. This is an EventEmitter that emits the following events:
      *
@@ -142,45 +147,146 @@ class Watcher {
     /**
      * Build the URL and request options for the watch.
      *
+     * @param isWatch - whether the request is for a watch operation
+     * @param resourceVersion - the resource version to use for the watch
+     * @param continueToken - the continue token for the watch
+     *
      * @returns the URL and request options
      */
-    #buildURL = async () => {
+    #buildURL = async (isWatch, resourceVersion, continueToken) => {
         // Build the path and query params for the resource, excluding the name
         const { opts, serverUrl } = await (0, utils_1.k8sCfg)("GET");
         const url = (0, utils_1.pathBuilder)(serverUrl, this.#model, this.#filters, true);
         // Enable the watch query param
-        url.searchParams.set("watch", "true");
+        if (isWatch) {
+            url.searchParams.set("watch", "true");
+        }
+        if (continueToken) {
+            url.searchParams.set("continue", continueToken);
+        }
         // If a name is specified, add it to the query params
         if (this.#filters.name) {
             url.searchParams.set("fieldSelector", `metadata.name=${this.#filters.name}`);
         }
         // If a resource version is specified, add it to the query params
-        if (this.#watchCfg.resourceVersion) {
-            url.searchParams.set("resourceVersion", this.#watchCfg.resourceVersion);
+        if (resourceVersion) {
+            url.searchParams.set("resourceVersion", resourceVersion);
         }
-        // Enable watch bookmarks
-        url.searchParams.set("allowWatchBookmarks", this.#watchCfg.allowWatchBookmarks ? `${this.#watchCfg.allowWatchBookmarks}` : "true");
         // Add the abort signal to the request options
         opts.signal = this.#abortController.signal;
         return { opts, url };
     };
-    /** Run the watch. */
-    #runner = async () => {
+    /**
+     * Retrieve the list of resources and process the events.
+     *
+     * @param continueToken - the continue token for the list
+     * @param removedItems - the list of items that have been removed
+     */
+    #list = async (continueToken, removedItems) => {
         try {
+            const { opts, url } = await this.#buildURL(false, undefined, continueToken);
+            // Make the request to list the resources
+            const response = await (0, fetch_1.fetch)(url, opts);
+            const list = response.data;
+            // If the request fails, emit an error event and return
+            if (!response.ok) {
+                this.#events.emit(WatchEvent.LIST_ERROR, new Error(`list failed: ${response.status} ${response.statusText}`));
+                return;
+            }
+            // Gross hack, thanks upstream library :<
+            if (list.metadata.continue) {
+                continueToken = list.metadata.continue;
+            }
+            // Emit the list event
+            this.#events.emit(WatchEvent.LIST, list);
+            // Update the resource version from the list metadata
+            this.#resourceVersion = list.metadata?.resourceVersion;
+            // If removed items are not provided, clone the cache
+            removedItems = removedItems || new Map(this.#cache.entries());
+            // Process each item in the list
+            for (const item of list.items || []) {
+                const { uid } = item.metadata;
+                // Remove the item from the removed items list
+                const alreadyExists = removedItems.delete(uid);
+                // If the item does not exist, it is new and should be added
+                if (!alreadyExists) {
+                    // Send added event. Use void here because we don't care about the result (no consequences here if it fails)
+                    void this.#process(item, types_1.WatchPhase.Added);
+                    continue;
+                }
+                // Check if the resource version has changed for items that already exist
+                const cachedRV = parseInt(this.#cache.get(uid)?.metadata?.resourceVersion);
+                const itemRV = parseInt(item.metadata.resourceVersion);
+                // Check if the resource version is newer than the cached version
+                if (itemRV > cachedRV) {
+                    // Send a modified event if the resource version has changed
+                    void this.#process(item, types_1.WatchPhase.Modified);
+                }
+            }
+            // If there is a continue token, call the list function again with the same removed items
+            if (continueToken) {
+                // If there is a continue token, call the list function again with the same removed items
+                // @todo: using all voids here is important for freshness, but is naive with regard to API load & pod resources
+                await this.#list(continueToken, removedItems);
+            }
+            else {
+                // Otherwise, process the removed items
+                for (const item of removedItems.values()) {
+                    void this.#process(item, types_1.WatchPhase.Deleted);
+                }
+            }
+        }
+        catch (err) {
+            this.#events.emit(WatchEvent.LIST_ERROR, err);
+        }
+    };
+    /**
+     * Process the event payload.
+     *
+     * @param payload - the event payload
+     * @param phase - the event phase
+     */
+    #process = async (payload, phase) => {
+        try {
+            switch (phase) {
+                // If the event is added or modified, update the cache
+                case types_1.WatchPhase.Added:
+                case types_1.WatchPhase.Modified:
+                    this.#cache.set(payload.metadata.uid, payload);
+                    break;
+                // If the event is deleted, remove the item from the cache
+                case types_1.WatchPhase.Deleted:
+                    this.#cache.delete(payload.metadata.uid);
+                    break;
+            }
+            // Emit the data event
+            this.#events.emit(WatchEvent.DATA, payload, phase);
+            // Call the callback function with the parsed payload
+            await this.#callback(payload, phase);
+        }
+        catch (err) {
+            this.#events.emit(WatchEvent.DATA_ERROR, err);
+        }
+    };
+    /**
+     * Watch for changes to the resource.
+     */
+    #watch = async () => {
+        try {
+            // Start with a list operation
+            await this.#list();
             // Build the URL and request options
-            const { opts, url } = await this.#buildURL();
+            const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
             // Create a stream to read the response body
             this.#stream = byline_1.default.createStream();
             // Bind the stream events
             this.#stream.on("error", this.#errHandler);
-            this.#stream.on("close", this.#cleanup);
-            this.#stream.on("finish", this.#cleanup);
+            this.#stream.on("close", this.#streamCleanup);
+            this.#stream.on("finish", this.#streamCleanup);
             // Make the actual request
             const response = await (0, node_fetch_1.default)(url, { ...opts });
             // Reset the pending reconnect flag
             this.#pendingReconnect = false;
-            // Reset the resync timer
-            void this.#scheduleResync();
             // If the request is successful, start listening for events
             if (response.ok) {
                 this.#events.emit(WatchEvent.CONNECT, url.pathname);
@@ -192,25 +298,17 @@ class Watcher {
                     try {
                         // Parse the event payload
                         const { object: payload, type: phase } = JSON.parse(line);
-                        void this.#scheduleResync();
+                        // Update the last seen time
+                        this.#lastSeenTime = Date.now();
                         // If the watch is too old, remove the resourceVersion and reload the watch
                         if (phase === types_1.WatchPhase.Error && payload.code === 410) {
                             throw {
                                 name: "TooOld",
-                                message: this.#watchCfg.resourceVersion,
+                                message: this.#resourceVersion,
                             };
                         }
-                        // If the event is a bookmark, emit the event and skip the callback
-                        if (phase === types_1.WatchPhase.Bookmark) {
-                            this.#events.emit(WatchEvent.BOOKMARK, payload);
-                        }
-                        else {
-                            this.#events.emit(WatchEvent.DATA, payload, phase);
-                            // Call the callback function with the parsed payload
-                            await this.#callback(payload, phase);
-                        }
-                        // Update the resource version if the callback was successful
-                        this.#setResourceVersion(payload.metadata.resourceVersion);
+                        // Process the event payload, do not update the resource version as that is handled by the list operation
+                        await this.#process(payload, phase);
                     }
                     catch (err) {
                         if (err.name === "TooOld") {
@@ -225,8 +323,8 @@ class Watcher {
                 });
                 // Bind the body events
                 body.on("error", this.#errHandler);
-                body.on("close", this.#cleanup);
-                body.on("finish", this.#cleanup);
+                body.on("close", this.#streamCleanup);
+                body.on("finish", this.#streamCleanup);
                 // Pipe the response body to the stream
                 body.pipe(this.#stream);
             }
@@ -238,64 +336,38 @@ class Watcher {
             void this.#errHandler(e);
         }
     };
-    /**
-     * Resync the watch.
-     *
-     * @returns the error handler
-     */
-    #resync = () => this.#errHandler({
-        name: "Resync",
-        message: "Resync triggered by resyncIntervalSec",
-    });
     /** Clear the resync timer and schedule a new one. */
-    #scheduleResync = async () => {
-        clearTimeout(this.#resyncTimer);
-        this.#resyncTimer = setTimeout(this.#resync, this.#watchCfg.resyncIntervalSec * 1000);
-    };
-    /**
-     * Update the resource version.
-     *
-     * @param resourceVersion - the new resource version
-     */
-    #setResourceVersion = (resourceVersion) => {
-        this.#watchCfg.resourceVersion = resourceVersion;
-        this.#events.emit(WatchEvent.RESOURCE_VERSION, resourceVersion);
-    };
-    /**
-     * Reload the watch after an error.
-     *
-     * @param err - the error that occurred
-     */
-    #reconnect = async (err) => {
-        // If there are more attempts, retry the watch (undefined is unlimited retries)
-        if (this.#watchCfg.retryMax === undefined || this.#watchCfg.retryMax > this.#retryCount) {
-            // Sleep for the specified delay, but check every 500ms if the watch has been aborted
-            let delay = this.#watchCfg.retryDelaySec * 1000;
-            while (delay > 0) {
-                if (this.#abortController.signal.aborted) {
-                    return;
+    #checkResync = () => {
+        // Ignore if the last seen time is not set
+        if (this.#lastSeenTime === NONE) {
+            return;
+        }
+        const now = Date.now();
+        // If the last seen time is greater than the limit, trigger a resync
+        if (this.#lastSeenTime == OVERRIDE || now - this.#lastSeenTime > this.#lastSeenLimit) {
+            // Reset the last seen time to now to allow the resync to be called again in case of failure
+            this.#lastSeenTime = now;
+            // If there are more attempts, retry the watch (undefined is unlimited retries)
+            if (this.#watchCfg.retryMax === undefined || this.#watchCfg.retryMax > this.#retryCount) {
+                // Increment the retry count
+                this.#retryCount++;
+                if (this.#pendingReconnect) {
+                    // wait for the connection to be re-established
+                    this.#events.emit(WatchEvent.RECONNECT_PENDING);
+                }
+                else {
+                    this.#pendingReconnect = true;
+                    this.#events.emit(WatchEvent.RECONNECT, this.#retryCount);
+                    this.#streamCleanup();
+                    void this.#watch();
                 }
-                delay -= 500;
-                await new Promise(resolve => setTimeout(resolve, 500));
-            }
-            this.#retryCount++;
-            this.#events.emit(WatchEvent.RECONNECT, err, this.#retryCount);
-            if (this.#pendingReconnect) {
-                // wait for the connection to be re-established
-                this.#events.emit(WatchEvent.RECONNECT_PENDING);
             }
             else {
-                this.#pendingReconnect = true;
-                this.#cleanup();
-                // Retry the watch after the delay
-                await this.#runner();
+                // Otherwise, call the finally function if it exists
+                this.#events.emit(WatchEvent.GIVE_UP, new Error(`Retry limit (${this.#watchCfg.retryMax}) exceeded, giving up`));
+                this.close();
             }
         }
-        else {
-            // Otherwise, call the finally function if it exists
-            this.#events.emit(WatchEvent.GIVE_UP, err);
-            this.close();
-        }
     };
     /**
      * Handle errors from the stream.
@@ -305,26 +377,25 @@ class Watcher {
     #errHandler = async (err) => {
         switch (err.name) {
             case "AbortError":
-                clearTimeout(this.#resyncTimer);
-                this.#cleanup();
+                clearInterval(this.$relistTimer);
+                clearInterval(this.#resyncTimer);
+                this.#streamCleanup();
                 this.#events.emit(WatchEvent.ABORT, err);
                 return;
             case "TooOld":
                 // Purge the resource version if it is too old
-                this.#setResourceVersion(undefined);
+                this.#resourceVersion = undefined;
                 this.#events.emit(WatchEvent.OLD_RESOURCE_VERSION, err.message);
                 break;
-            case "Resync":
-                this.#events.emit(WatchEvent.RESYNC, err);
-                break;
             default:
                 this.#events.emit(WatchEvent.NETWORK_ERROR, err);
                 break;
         }
-        await this.#reconnect(err);
+        // Force a resync
+        this.#lastSeenTime = OVERRIDE;
     };
     /** Cleanup the stream and listeners. */
-    #cleanup = () => {
+    #streamCleanup = () => {
         if (this.#stream) {
             this.#stream.removeAllListeners();
             this.#stream.destroy();