kubernetes-fluent-client 3.2.2 → 3.3.0

package/dist/fluent/watch.d.ts

@@ -1,4 +1,6 @@
 import { EventEmitter } from "events";
+import { RequestInit } from "node-fetch";
+import { Agent } from "undici";
 import { GenericClass } from "../types";
 import { Filters, WatchAction } from "./types";
 export declare enum WatchEvent {
@@ -41,8 +43,8 @@ export type WatchCfg = {
     relistIntervalSec?: number;
     /** Max amount of seconds to go without receiving an event before reconciliation starts. Defaults to 300 (5 minutes). */
     lastSeenLimitSeconds?: number;
-    /** Use http2 for the Watch */
-    useHTTP2?: boolean;
+    /** Watch Mechansism */
+    useLegacyWatch?: boolean;
 };
 /** A wrapper around the Kubernetes watch API. */
 export declare class Watcher<T extends GenericClass> {
@@ -84,5 +86,6 @@ export declare class Watcher<T extends GenericClass> {
      * @returns an EventEmitter
      */
     get events(): EventEmitter;
+    static getHTTPSAgent: (opts: RequestInit) => Agent;
 }
 //# sourceMappingURL=watch.d.ts.map

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;AAKtC,OAAO,EAAE,YAAY,EAAwB,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAqC,MAAM,SAAS,CAAC;AAIlF,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;IACzB,mBAAmB;IACnB,UAAU,eAAe;IACzB,qCAAqC;IACrC,wBAAwB,6BAA6B;IACrD,iCAAiC;IACjC,eAAe,oBAAoB;CACpC;AAED,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG;IACrB,+HAA+H;IAC/H,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wHAAwH;IACxH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAKF,iDAAiD;AACjD,qBAAa,OAAO,CAAC,CAAC,SAAS,YAAY;;IA0BzC,YAAY,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAgB9B;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,QAAa;IA6CzF;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAU9C,gGAAgG;IACzF,KAAK;IAOZ;;;;;OAKG;IACI,UAAU;IAWjB;;;;;;OAMG;IACH,IAAW,MAAM,IAAI,YAAY,CAEhC;CAufF"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC,OAAoB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,KAAK,EAAS,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,YAAY,EAAwB,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAK3D,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;IACzB,mBAAmB;IACnB,UAAU,eAAe;IACzB,qCAAqC;IACrC,wBAAwB,6BAA6B;IACrD,iCAAiC;IACjC,eAAe,oBAAoB;CACpC;AAED,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG;IACrB,+HAA+H;IAC/H,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wHAAwH;IACxH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,uBAAuB;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAKF,iDAAiD;AACjD,qBAAa,OAAO,CAAC,CAAC,SAAS,YAAY;;IA0BzC,YAAY,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAgB9B;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,QAAa;IA6CzF;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAU9C,gGAAgG;IACzF,KAAK;IAWZ;;;;;OAKG;IACI,UAAU;IAWjB;;;;;;OAMG;IACH,IAAW,MAAM,IAAI,YAAY,CAEhC;IA+PD,MAAM,CAAC,aAAa,SAAU,WAAW,WAqBvC;CA+KH"}

package/dist/fluent/watch.js

@@ -7,15 +7,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Watcher = exports.WatchEvent = void 0;
-const byline_1 = __importDefault(require("byline"));
 const crypto_1 = require("crypto");
 const events_1 = require("events");
+const byline_1 = __importDefault(require("byline"));
 const https_1 = __importDefault(require("https"));
-const http2_1 = __importDefault(require("http2"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const undici_1 = require("undici");
 const fetch_1 = require("../fetch");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
+const stream_1 = require("stream");
 const fs_1 = __importDefault(require("fs"));
 var WatchEvent;
 (function (WatchEvent) {
@@ -58,7 +59,7 @@ class Watcher {
     #callback;
     #watchCfg;
     #latestRelistWindow = "";
-    #useHTTP2 = false;
+    #useLegacyWatch = false;
     // Track the last time data was received
     #lastSeenTime = NONE;
     #lastSeenLimit;
@@ -68,6 +69,7 @@ class Watcher {
     #resyncFailureCount = 0;
     // Create a stream to read the response body
     #stream;
+    #legacyStream;
     // Create an EventEmitter to emit events
     #events = new events_1.EventEmitter();
     // Create a timer to relist the watch
@@ -101,12 +103,12 @@ class Watcher {
         watchCfg.relistIntervalSec ??= 600;
         // Set the resync interval to 10 minutes if not specified
         watchCfg.lastSeenLimitSeconds ??= 600;
+        // Set the watch mechanism
+        this.#useLegacyWatch = watchCfg.useLegacyWatch || false;
         // Set the last seen limit to the resync interval
         this.#lastSeenLimit = watchCfg.lastSeenLimitSeconds * 1000;
         // Set the latest relist interval to now
         this.#latestRelistWindow = new Date().toISOString();
-        // Set the latest relist interval to now
-        this.#useHTTP2 = watchCfg.useHTTP2 ?? false;
         // 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
@@ -132,8 +134,8 @@ class Watcher {
      */
     async start() {
         this.#events.emit(WatchEvent.INIT_CACHE_MISS, this.#latestRelistWindow);
-        if (this.#useHTTP2) {
-            await this.#http2Watch();
+        if (this.#useLegacyWatch) {
+            await this.#legacyWatch();
         }
         else {
             await this.#watch();
@@ -144,7 +146,12 @@ class Watcher {
     close() {
         clearInterval(this.$relistTimer);
         clearInterval(this.#resyncTimer);
-        this.#streamCleanup();
+        if (this.#useLegacyWatch) {
+            this.#legacyStreamCleanup();
+        }
+        else {
+            this.#streamCleanup();
+        }
         this.#abortController.abort();
     }
     /**
@@ -269,7 +276,6 @@ class Watcher {
             // 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 {
@@ -338,42 +344,40 @@ class Watcher {
             this.#events.emit(WatchEvent.DATA_ERROR, err);
         }
     };
-    /**
-     * Watch for changes to the resource.
-     */
-    #watch = async () => {
+    /** node-fetch watch */
+    #legacyWatch = async () => {
         try {
             // Start with a list operation
             await this.#list();
             // Build the URL and request options
             const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
             // Create a stream to read the response body
-            this.#stream = byline_1.default.createStream();
+            this.#legacyStream = byline_1.default.createStream();
             // Bind the stream events
-            this.#stream.on("error", this.#errHandler);
-            this.#stream.on("close", this.#streamCleanup);
-            this.#stream.on("finish", this.#streamCleanup);
+            this.#legacyStream.on("error", this.#errHandler);
+            this.#legacyStream.on("close", this.#legacyStreamCleanup);
+            this.#legacyStream.on("finish", this.#legacyStreamCleanup);
             // Make the actual request
             const response = await (0, node_fetch_1.default)(url, { ...opts });
-            // Reset the pending reconnect flag
-            this.#pendingReconnect = false;
             // If the request is successful, start listening for events
             if (response.ok) {
+                // Reset the pending reconnect flag
+                this.#pendingReconnect = false;
                 this.#events.emit(WatchEvent.CONNECT, url.pathname);
                 const { body } = response;
                 // Reset the retry count
                 this.#resyncFailureCount = 0;
                 this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
                 // Listen for events and call the callback function
-                this.#stream.on("data", async (line) => {
+                this.#legacyStream.on("data", async (line) => {
                     await this.#processLine(line, this.#process);
                 });
                 // Bind the body events
                 body.on("error", this.#errHandler);
-                body.on("close", this.#streamCleanup);
-                body.on("finish", this.#streamCleanup);
+                body.on("close", this.#legacyStreamCleanup);
+                body.on("finish", this.#legacyStreamCleanup);
                 // Pipe the response body to the stream
-                body.pipe(this.#stream);
+                body.pipe(this.#legacyStream);
             }
             else {
                 throw new Error(`watch connect failed: ${response.status} ${response.statusText}`);
@@ -383,69 +387,84 @@ class Watcher {
             void this.#errHandler(e);
         }
     };
-    // Configure the agent options for the HTTP/2 client
-    static #getAgentOptions(opts) {
-        if (opts.agent && opts.agent instanceof https_1.default.Agent) {
-            return {
-                key: opts.agent.options.key,
-                cert: opts.agent.options.cert,
+    static getHTTPSAgent = (opts) => {
+        // In cluster there will be agent - testing or dev no
+        const agentOptions = opts.agent instanceof https_1.default.Agent
+            ? {
                 ca: opts.agent.options.ca,
-                rejectUnauthorized: false,
+                cert: opts.agent.options.cert,
+                key: opts.agent.options.key,
+            }
+            : {
+                ca: undefined,
+                cert: undefined,
+                key: undefined,
             };
-        }
-        return undefined;
-    }
-    // Create an HTTP/2 client
-    static #createHttp2Client(origin, agentOptions) {
-        return http2_1.default.connect(origin, {
-            ca: agentOptions?.ca,
-            cert: agentOptions?.cert,
-            key: agentOptions?.key,
-            rejectUnauthorized: agentOptions?.rejectUnauthorized,
+        return new undici_1.Agent({
+            keepAliveMaxTimeout: 600000,
+            keepAliveTimeout: 600000,
+            bodyTimeout: 0,
+            connect: agentOptions,
         });
-    }
-    // Generate the request headers for the HTTP/2 request
-    #generateRequestHeaders = async (url) => {
-        const token = await this.#getToken();
-        const headers = {
-            ":method": "GET",
-            ":path": url.pathname + url.search,
-            "content-type": "application/json",
-            "user-agent": "kubernetes-fluent-client",
-        };
-        if (token) {
-            headers["Authorization"] = `Bearer ${token}`;
-        }
-        return headers;
     };
     /**
      * Watch for changes to the resource.
      */
-    #http2Watch = async () => {
+    #watch = async () => {
         try {
             // Start with a list operation
             await this.#list();
             // Build the URL and request options
             const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
-            const agentOptions = _a.#getAgentOptions(opts);
-            // HTTP/2 client connection setup
-            const client = _a.#createHttp2Client(url.origin, agentOptions);
-            // Handle client connection errors
-            client.on("error", err => {
-                this.#events.emit(WatchEvent.NETWORK_ERROR, err);
-                this.#cleanupAndReconnect(client, err);
-            });
-            // Set up headers for the HTTP/2 request
-            const headers = await this.#generateRequestHeaders(url);
-            // Make the HTTP/2 request
-            const req = client.request(headers);
-            req.setEncoding("utf8");
-            // Handler events for the HTTP/2 request
-            this.#handleHttp2Request(req, client);
-            // Handle abort signal
-            this.#abortController.signal.addEventListener("abort", () => {
-                this.#streamCleanup(client);
+            const token = await this.#getToken();
+            const headers = {
+                "Content-Type": "application/json",
+                "User-Agent": "kubernetes-fluent-client",
+            };
+            if (token) {
+                headers["Authorization"] = `Bearer ${token}`;
+            }
+            const response = await (0, undici_1.fetch)(url, {
+                headers,
+                dispatcher: _a.getHTTPSAgent(opts),
             });
+            // If the request is successful, start listening for events
+            if (response.ok) {
+                // Reset the pending reconnect flag
+                this.#pendingReconnect = false;
+                this.#events.emit(WatchEvent.CONNECT, url.pathname);
+                const { body } = response;
+                if (!body) {
+                    throw new Error("No response body found");
+                }
+                // Reset the retry count
+                this.#resyncFailureCount = 0;
+                this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
+                this.#stream = stream_1.Readable.from(body);
+                const decoder = new TextDecoder();
+                let buffer = "";
+                // Listen for events and call the callback function
+                this.#stream.on("data", async (chunk) => {
+                    try {
+                        buffer += decoder.decode(chunk, { stream: true });
+                        const lines = buffer.split("\n");
+                        buffer = lines.pop();
+                        for (const line of lines) {
+                            await this.#processLine(line, this.#process);
+                        }
+                    }
+                    catch (err) {
+                        void this.#errHandler(err);
+                    }
+                });
+                this.#stream.on("close", this.#cleanupAndReconnect);
+                this.#stream.on("end", this.#cleanupAndReconnect);
+                this.#stream.on("error", this.#errHandler);
+                this.#stream.on("finish", this.#cleanupAndReconnect);
+            }
+            else {
+                throw new Error(`watch connect failed: ${response.status} ${response.statusText}`);
+            }
         }
         catch (e) {
             void this.#errHandler(e);
@@ -475,12 +494,12 @@ class Watcher {
                 else {
                     this.#pendingReconnect = true;
                     this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
-                    this.#streamCleanup();
-                    if (this.#useHTTP2) {
-                        this.#cleanupAndReconnect();
+                    if (this.#useLegacyWatch) {
+                        this.#legacyStreamCleanup();
+                        void this.#legacyWatch();
                     }
-                    if (!this.#useHTTP2) {
-                        void this.#watch();
+                    else {
+                        this.#cleanupAndReconnect();
                     }
                 }
             }
@@ -501,9 +520,11 @@ class Watcher {
             case "AbortError":
                 clearInterval(this.$relistTimer);
                 clearInterval(this.#resyncTimer);
-                this.#streamCleanup();
-                if (!this.#useHTTP2) {
-                    this.#scheduleReconnect();
+                if (this.#useLegacyWatch) {
+                    this.#legacyStreamCleanup();
+                }
+                else {
+                    this.#streamCleanup();
                 }
                 this.#events.emit(WatchEvent.ABORT, err);
                 return;
@@ -519,80 +540,24 @@ class Watcher {
         // Force a resync
         this.#lastSeenTime = OVERRIDE;
     };
-    /**
-     *
-     * @param req - the request stream
-     * @param client - the client session
-     */
-    #handleHttp2Request(req, client) {
-        let buffer = "";
-        req.on("response", headers => {
-            const statusCode = headers[":status"];
-            if (statusCode && statusCode >= 200 && statusCode < 300) {
-                this.#onWatchConnected();
-            }
-            else {
-                this.#cleanupAndReconnect(client, new Error(`watch connect failed: ${statusCode}`));
-            }
-        });
-        req.on("data", chunk => {
-            buffer += chunk;
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || ""; // Keep any incomplete line for the next chunk
-            lines.forEach(line => {
-                void this.#processLine(line, this.#process);
-            });
-        });
-        req.on("end", () => this.#cleanupAndReconnect(client));
-        req.on("close", () => this.#cleanupAndReconnect(client));
-        req.on("error", error => this.#errHandler(error));
-    }
-    /** Schedules a reconnect with a delay to prevent rapid reconnections. */
-    #scheduleReconnect() {
-        const jitter = Math.floor(Math.random() * 1000);
-        const delay = (this.#watchCfg.resyncDelaySec ?? 5) * 1000 + jitter;
-        setTimeout(() => {
-            this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
-            void this.#http2Watch();
-        }, delay);
-    }
-    /**
-     * Handle a successful connection to the watch.
-     */
-    #onWatchConnected() {
-        this.#pendingReconnect = false;
-        this.#events.emit(WatchEvent.CONNECT);
-        // Reset the retry count
-        this.#resyncFailureCount = 0;
-        this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
-    }
-    /**
-     * Cleanup the stream and listeners.
-     *
-     * @param client - the client session
-     */
-    #streamCleanup = (client) => {
+    /** Cleanup the stream and connect */
+    #cleanupAndReconnect = () => {
+        this.#streamCleanup();
+        void this.#watch();
+    };
+    /** Cleanup the stream and listeners. */
+    #streamCleanup = () => {
         if (this.#stream) {
             this.#stream.removeAllListeners();
             this.#stream.destroy();
         }
-        if (client) {
-            client.close();
-        }
     };
-    /**
-     * Cleanup the stream and listeners and reconnect.
-     *
-     * @param client - the client session
-     * @param error - the error that occurred
-     */
-    #cleanupAndReconnect(client, error) {
-        this.#streamCleanup(client);
-        if (error) {
-            void this.#errHandler(error);
+    #legacyStreamCleanup = () => {
+        if (this.#legacyStream) {
+            this.#legacyStream.removeAllListeners();
+            this.#legacyStream.destroy();
         }
-        this.#scheduleReconnect();
-    }
+    };
 }
 exports.Watcher = Watcher;
 _a = Watcher;

package/eslint.config.mjs

@@ -0,0 +1,66 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default [
+  {
+    ignores: ["**/node_modules", "**/dist", "**/__mocks__", "e2e/crds", "e2e/crds"],
+  },
+  ...compat.extends(
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:jsdoc/recommended-typescript-error",
+  ),
+  {
+    plugins: {
+      "@typescript-eslint": typescriptEslint,
+    },
+
+    languageOptions: {
+      globals: {
+        ...Object.fromEntries(Object.entries(globals.browser).map(([key]) => [key, "off"])),
+      },
+
+      parser: tsParser,
+      ecmaVersion: 2022,
+      sourceType: "script",
+
+      parserOptions: {
+        project: ["tsconfig.json"],
+      },
+    },
+
+    rules: {
+      "class-methods-use-this": "warn",
+      "consistent-this": "warn",
+      "no-invalid-this": "warn",
+
+      "@typescript-eslint/no-floating-promises": [
+        "warn",
+        {
+          ignoreVoid: true,
+        },
+      ],
+
+      "jsdoc/tag-lines": [
+        "error",
+        "any",
+        {
+          startLines: 1,
+        },
+      ],
+    },
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubernetes-fluent-client",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "description": "A @kubernetes/client-node fluent API wrapper that leverages K8s Server Side Apply.",
   "bin": "./dist/cli.js",
   "main": "dist/index.js",
@@ -44,19 +44,23 @@
     "node-fetch": "2.7.0",
     "quicktype-core": "23.0.170",
     "type-fest": "4.26.1",
+    "undici": "6.20.1",
     "yargs": "17.7.2"
   },
   "devDependencies": {
     "@commitlint/cli": "19.5.0",
     "@commitlint/config-conventional": "19.5.0",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.14.0",
     "@jest/globals": "29.7.0",
     "@types/byline": "4.2.36",
-    "@types/readable-stream": "4.0.16",
+    "@types/readable-stream": "4.0.18",
     "@types/urijs": "^1.19.25",
     "@types/yargs": "17.0.33",
-    "@typescript-eslint/eslint-plugin": "8.12.2",
-    "@typescript-eslint/parser": "8.12.2",
+    "@typescript-eslint/eslint-plugin": "8.13.0",
+    "@typescript-eslint/parser": "8.13.0",
     "eslint-plugin-jsdoc": "50.4.3",
+    "globals": "^15.12.0",
     "husky": "^9.1.6",
     "jest": "29.7.0",
     "lint-staged": "^15.2.10",

package/src/fluent/watch.ts

@@ -1,16 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
 
-import byline from "byline";
 import { createHash } from "crypto";
 import { EventEmitter } from "events";
+import byline from "byline";
 import https from "https";
-import http2 from "http2";
-import fetch from "node-fetch";
+import legacyFetch, { RequestInit } from "node-fetch";
+import { Agent, fetch } from "undici";
 import { fetch as wrappedFetch } from "../fetch";
 import { GenericClass, KubernetesListObject } from "../types";
-import { Filters, WatchAction, WatchPhase, Options, AgentOptions } from "./types";
+import { Filters, WatchAction, WatchPhase } from "./types";
 import { k8sCfg, pathBuilder } from "./utils";
+import { Readable } from "stream";
 import fs from "fs";
 
 export enum WatchEvent {
@@ -54,8 +55,8 @@ export type WatchCfg = {
   relistIntervalSec?: number;
   /** Max amount of seconds to go without receiving an event before reconciliation starts. Defaults to 300 (5 minutes). */
   lastSeenLimitSeconds?: number;
-  /** Use http2 for the Watch */
-  useHTTP2?: boolean;
+  /** Watch Mechansism */
+  useLegacyWatch?: boolean;
 };
 
 const NONE = 50;
@@ -69,8 +70,7 @@ export class Watcher<T extends GenericClass> {
   #callback: WatchAction<T>;
   #watchCfg: WatchCfg;
   #latestRelistWindow: string = "";
-  #useHTTP2: boolean = false;
-
+  #useLegacyWatch = false;
   // Track the last time data was received
   #lastSeenTime = NONE;
   #lastSeenLimit: number;
@@ -82,7 +82,8 @@ export class Watcher<T extends GenericClass> {
   #resyncFailureCount = 0;
 
   // Create a stream to read the response body
-  #stream?: byline.LineStream;
+  #stream?: Readable;
+  #legacyStream?: byline.LineStream;
 
   // Create an EventEmitter to emit events
   #events = new EventEmitter();
@@ -126,15 +127,15 @@ export class Watcher<T extends GenericClass> {
     // Set the resync interval to 10 minutes if not specified
     watchCfg.lastSeenLimitSeconds ??= 600;
 
+    // Set the watch mechanism
+    this.#useLegacyWatch = watchCfg.useLegacyWatch || false;
+
     // Set the last seen limit to the resync interval
     this.#lastSeenLimit = watchCfg.lastSeenLimitSeconds * 1000;
 
     // Set the latest relist interval to now
     this.#latestRelistWindow = new Date().toISOString();
 
-    // Set the latest relist interval to now
-    this.#useHTTP2 = watchCfg.useHTTP2 ?? false;
-
     // Add random jitter to the relist/resync intervals (up to 1 second)
     const jitter = Math.floor(Math.random() * 1000);
 
@@ -168,8 +169,8 @@ export class Watcher<T extends GenericClass> {
    */
   public async start(): Promise<AbortController> {
     this.#events.emit(WatchEvent.INIT_CACHE_MISS, this.#latestRelistWindow);
-    if (this.#useHTTP2) {
-      await this.#http2Watch();
+    if (this.#useLegacyWatch) {
+      await this.#legacyWatch();
     } else {
       await this.#watch();
     }
@@ -180,7 +181,11 @@ export class Watcher<T extends GenericClass> {
   public close() {
     clearInterval(this.$relistTimer);
     clearInterval(this.#resyncTimer);
-    this.#streamCleanup();
+    if (this.#useLegacyWatch) {
+      this.#legacyStreamCleanup();
+    } else {
+      this.#streamCleanup();
+    }
     this.#abortController.abort();
   }
 
@@ -333,7 +338,6 @@ export class Watcher<T extends GenericClass> {
       // 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
@@ -413,11 +417,8 @@ export class Watcher<T extends GenericClass> {
       this.#events.emit(WatchEvent.DATA_ERROR, err);
     }
   };
-
-  /**
-   * Watch for changes to the resource.
-   */
-  #watch = async () => {
+  /** node-fetch watch */
+  #legacyWatch = async () => {
     try {
       // Start with a list operation
       await this.#list();
@@ -426,21 +427,21 @@ export class Watcher<T extends GenericClass> {
       const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
 
       // Create a stream to read the response body
-      this.#stream = byline.createStream();
+      this.#legacyStream = byline.createStream();
 
       // Bind the stream events
-      this.#stream.on("error", this.#errHandler);
-      this.#stream.on("close", this.#streamCleanup);
-      this.#stream.on("finish", this.#streamCleanup);
+      this.#legacyStream.on("error", this.#errHandler);
+      this.#legacyStream.on("close", this.#legacyStreamCleanup);
+      this.#legacyStream.on("finish", this.#legacyStreamCleanup);
 
       // Make the actual request
-      const response = await fetch(url, { ...opts });
-
-      // Reset the pending reconnect flag
-      this.#pendingReconnect = false;
+      const response = await legacyFetch(url, { ...opts });
 
       // If the request is successful, start listening for events
       if (response.ok) {
+        // Reset the pending reconnect flag
+        this.#pendingReconnect = false;
+
         this.#events.emit(WatchEvent.CONNECT, url.pathname);
 
         const { body } = response;
@@ -450,17 +451,17 @@ export class Watcher<T extends GenericClass> {
         this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
 
         // Listen for events and call the callback function
-        this.#stream.on("data", async line => {
+        this.#legacyStream.on("data", async line => {
           await this.#processLine(line, this.#process);
         });
 
         // Bind the body events
         body.on("error", this.#errHandler);
-        body.on("close", this.#streamCleanup);
-        body.on("finish", this.#streamCleanup);
+        body.on("close", this.#legacyStreamCleanup);
+        body.on("finish", this.#legacyStreamCleanup);
 
         // Pipe the response body to the stream
-        body.pipe(this.#stream);
+        body.pipe(this.#legacyStream);
       } else {
         throw new Error(`watch connect failed: ${response.status} ${response.statusText}`);
       }
@@ -469,79 +470,97 @@ export class Watcher<T extends GenericClass> {
     }
   };
 
-  // Configure the agent options for the HTTP/2 client
-  static #getAgentOptions(opts: Options) {
-    if (opts.agent && opts.agent instanceof https.Agent) {
-      return {
-        key: opts.agent.options.key,
-        cert: opts.agent.options.cert,
-        ca: opts.agent.options.ca,
-        rejectUnauthorized: false,
-      };
-    }
-    return undefined;
-  }
-
-  // Create an HTTP/2 client
-  static #createHttp2Client(origin: string, agentOptions?: AgentOptions) {
-    return http2.connect(origin, {
-      ca: agentOptions?.ca,
-      cert: agentOptions?.cert,
-      key: agentOptions?.key,
-      rejectUnauthorized: agentOptions?.rejectUnauthorized,
+  static getHTTPSAgent = (opts: RequestInit) => {
+    // In cluster there will be agent - testing or dev no
+    const agentOptions =
+      opts.agent instanceof https.Agent
+        ? {
+            ca: opts.agent.options.ca,
+            cert: opts.agent.options.cert,
+            key: opts.agent.options.key,
+          }
+        : {
+            ca: undefined,
+            cert: undefined,
+            key: undefined,
+          };
+
+    return new Agent({
+      keepAliveMaxTimeout: 600000,
+      keepAliveTimeout: 600000,
+      bodyTimeout: 0,
+      connect: agentOptions,
     });
-  }
-
-  // Generate the request headers for the HTTP/2 request
-  #generateRequestHeaders = async (url: URL) => {
-    const token = await this.#getToken();
-    const headers: Record<string, string> = {
-      ":method": "GET",
-      ":path": url.pathname + url.search,
-      "content-type": "application/json",
-      "user-agent": "kubernetes-fluent-client",
-    };
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    return headers;
   };
-
   /**
    * Watch for changes to the resource.
    */
-  #http2Watch = async () => {
+  #watch = async () => {
     try {
       // Start with a list operation
       await this.#list();
 
       // Build the URL and request options
       const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
-      const agentOptions = Watcher.#getAgentOptions(opts as Options);
 
-      // HTTP/2 client connection setup
-      const client = Watcher.#createHttp2Client(url.origin, agentOptions);
+      const token = await this.#getToken();
+      const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+        "User-Agent": "kubernetes-fluent-client",
+      };
 
-      // Handle client connection errors
-      client.on("error", err => {
-        this.#events.emit(WatchEvent.NETWORK_ERROR, err);
-        this.#cleanupAndReconnect(client, err);
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+
+      const response = await fetch(url, {
+        headers,
+        dispatcher: Watcher.getHTTPSAgent(opts),
       });
 
-      // Set up headers for the HTTP/2 request
-      const headers = await this.#generateRequestHeaders(url);
+      // If the request is successful, start listening for events
+      if (response.ok) {
+        // Reset the pending reconnect flag
+        this.#pendingReconnect = false;
+
+        this.#events.emit(WatchEvent.CONNECT, url.pathname);
+
+        const { body } = response;
 
-      // Make the HTTP/2 request
-      const req = client.request(headers);
-      req.setEncoding("utf8");
+        if (!body) {
+          throw new Error("No response body found");
+        }
 
-      // Handler events for the HTTP/2 request
-      this.#handleHttp2Request(req, client);
+        // Reset the retry count
+        this.#resyncFailureCount = 0;
+        this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
 
-      // Handle abort signal
-      this.#abortController.signal.addEventListener("abort", () => {
-        this.#streamCleanup(client);
-      });
+        this.#stream = Readable.from(body);
+        const decoder = new TextDecoder();
+        let buffer = "";
+
+        // Listen for events and call the callback function
+        this.#stream.on("data", async chunk => {
+          try {
+            buffer += decoder.decode(chunk, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop()!;
+
+            for (const line of lines) {
+              await this.#processLine(line, this.#process);
+            }
+          } catch (err) {
+            void this.#errHandler(err);
+          }
+        });
+
+        this.#stream.on("close", this.#cleanupAndReconnect);
+        this.#stream.on("end", this.#cleanupAndReconnect);
+        this.#stream.on("error", this.#errHandler);
+        this.#stream.on("finish", this.#cleanupAndReconnect);
+      } else {
+        throw new Error(`watch connect failed: ${response.status} ${response.statusText}`);
+      }
     } catch (e) {
       void this.#errHandler(e);
     }
@@ -576,15 +595,12 @@ export class Watcher<T extends GenericClass> {
         } else {
           this.#pendingReconnect = true;
           this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
-          this.#streamCleanup();
-
-          if (this.#useHTTP2) {
+          if (this.#useLegacyWatch) {
+            this.#legacyStreamCleanup();
+            void this.#legacyWatch();
+          } else {
             this.#cleanupAndReconnect();
           }
-
-          if (!this.#useHTTP2) {
-            void this.#watch();
-          }
         }
       } else {
         // Otherwise, call the finally function if it exists
@@ -607,9 +623,10 @@ export class Watcher<T extends GenericClass> {
       case "AbortError":
         clearInterval(this.$relistTimer);
         clearInterval(this.#resyncTimer);
-        this.#streamCleanup();
-        if (!this.#useHTTP2) {
-          this.#scheduleReconnect();
+        if (this.#useLegacyWatch) {
+          this.#legacyStreamCleanup();
+        } else {
+          this.#streamCleanup();
         }
         this.#events.emit(WatchEvent.ABORT, err);
         return;
@@ -628,89 +645,25 @@ export class Watcher<T extends GenericClass> {
     // Force a resync
     this.#lastSeenTime = OVERRIDE;
   };
-  /**
-   *
-   * @param req - the request stream
-   * @param client - the client session
-   */
-  #handleHttp2Request(req: http2.ClientHttp2Stream, client: http2.ClientHttp2Session) {
-    let buffer = "";
-
-    req.on("response", headers => {
-      const statusCode = headers[":status"];
-      if (statusCode && statusCode >= 200 && statusCode < 300) {
-        this.#onWatchConnected();
-      } else {
-        this.#cleanupAndReconnect(client, new Error(`watch connect failed: ${statusCode}`));
-      }
-    });
-
-    req.on("data", chunk => {
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || ""; // Keep any incomplete line for the next chunk
-
-      lines.forEach(line => {
-        void this.#processLine(line, this.#process);
-      });
-    });
-
-    req.on("end", () => this.#cleanupAndReconnect(client));
-    req.on("close", () => this.#cleanupAndReconnect(client));
-    req.on("error", error => this.#errHandler(error));
-  }
-
-  /** Schedules a reconnect with a delay to prevent rapid reconnections. */
-  #scheduleReconnect() {
-    const jitter = Math.floor(Math.random() * 1000);
-    const delay = (this.#watchCfg.resyncDelaySec ?? 5) * 1000 + jitter;
 
-    setTimeout(() => {
-      this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
-      void this.#http2Watch();
-    }, delay);
-  }
-
-  /**
-   * Handle a successful connection to the watch.
-   */
-  #onWatchConnected() {
-    this.#pendingReconnect = false;
-    this.#events.emit(WatchEvent.CONNECT);
-
-    // Reset the retry count
-    this.#resyncFailureCount = 0;
-    this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
-  }
+  /** Cleanup the stream and connect */
+  #cleanupAndReconnect = () => {
+    this.#streamCleanup();
+    void this.#watch();
+  };
 
-  /**
-   * Cleanup the stream and listeners.
-   *
-   * @param client - the client session
-   */
-  #streamCleanup = (client?: http2.ClientHttp2Session) => {
+  /** Cleanup the stream and listeners. */
+  #streamCleanup = () => {
     if (this.#stream) {
       this.#stream.removeAllListeners();
       this.#stream.destroy();
     }
-    if (client) {
-      client.close();
-    }
   };
 
-  /**
-   * Cleanup the stream and listeners and reconnect.
-   *
-   * @param client - the client session
-   * @param error - the error that occurred
-   */
-  #cleanupAndReconnect(client?: http2.ClientHttp2Session, error?: Error) {
-    this.#streamCleanup(client);
-
-    if (error) {
-      void this.#errHandler(error);
+  #legacyStreamCleanup = () => {
+    if (this.#legacyStream) {
+      this.#legacyStream.removeAllListeners();
+      this.#legacyStream.destroy();
     }
-
-    this.#scheduleReconnect();
-  }
+  };
 }