kubernetes-fluent-client 3.0.3 → 4.0.0-rc-http2-watch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubernetes-fluent-client",
-  "version": "3.0.3",
+  "version": "4.0.0-rc-http2-watch",
   "description": "A @kubernetes/client-node fluent API wrapper that leverages K8s Server Side Apply.",
   "bin": "./dist/cli.js",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
     "build": "tsc",
     "semantic-release": "semantic-release",
     "test": "jest src --coverage",
+    "test:e2e": "jest e2e",
     "format:check": "eslint src && prettier . --check",
     "format:fix": "eslint --fix src && prettier . --write"
   },
@@ -52,13 +53,13 @@
     "@types/readable-stream": "4.0.15",
     "@types/urijs": "^1.19.25",
     "@types/yargs": "17.0.33",
-    "@typescript-eslint/eslint-plugin": "8.5.0",
-    "@typescript-eslint/parser": "8.5.0",
-    "eslint-plugin-jsdoc": "50.2.3",
+    "@typescript-eslint/eslint-plugin": "8.8.1",
+    "@typescript-eslint/parser": "8.8.1",
+    "eslint-plugin-jsdoc": "50.3.1",
     "jest": "29.7.0",
     "nock": "13.5.5",
     "prettier": "3.3.3",
-    "semantic-release": "24.1.1",
+    "semantic-release": "24.1.2",
     "ts-jest": "29.2.5",
     "typescript": "5.6.2"
   },

package/src/cli.ts

@@ -7,6 +7,8 @@ import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
 import { GenerateOptions, generate } from "./generate";
 import { version } from "../package.json";
+import { postProcessing } from "./postProcessing";
+import { NodeFileSystem } from "./fileSystem"; // Import your new file system
 
 void yargs(hideBin(process.argv))
   .version("version", "Display version number", `kubernetes-fluent-client v${version}`)
@@ -37,14 +39,36 @@ void yargs(hideBin(process.argv))
           description:
             "the language to generate types in, see https://github.com/glideapps/quicktype#target-languages for a list of supported languages",
         })
+        .option("noPost", {
+          alias: "x",
+          type: "boolean",
+          default: false,
+          description: "disable post-processing after generating the types",
+        })
         .demandOption(["source", "directory"]);
     },
     async argv => {
       const opts = argv as unknown as GenerateOptions;
       opts.logFn = console.log;
 
+      // Pass the `post` flag to opts
+      opts.noPost = argv.noPost as boolean;
+
+      // Use NodeFileSystem as the file system for post-processing
+      const fileSystem = new NodeFileSystem(); // Create an instance of NodeFileSystem
+
+      if (!opts.noPost) {
+        console.log("\n✅ Post-processing has been enabled.\n");
+      }
+
       try {
-        await generate(opts);
+        // Capture the results returned by generate
+        const allResults = await generate(opts);
+
+        // If noPost is false, run post-processing
+        if (!opts.noPost) {
+          await postProcessing(allResults, opts, fileSystem); // Pass the file system to postProcessing
+        }
       } catch (e) {
         console.log(`\n❌ ${e.message}`);
       }

package/src/fileSystem.test.ts

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+
+import * as fs from "fs";
+import { NodeFileSystem } from "./fileSystem";
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+// Mock the fs module
+jest.mock("fs");
+
+describe("NodeFileSystem", () => {
+  let nodeFileSystem: NodeFileSystem;
+
+  beforeEach(() => {
+    nodeFileSystem = new NodeFileSystem();
+    jest.clearAllMocks(); // Clear all mocks before each test
+  });
+
+  describe("readFile", () => {
+    test("should call fs.readFileSync with correct arguments", () => {
+      const mockFilePath = "test-file.txt";
+      const mockFileContent = "This is a test file";
+
+      // Mock the fs.readFileSync method to return the mock file content
+      (fs.readFileSync as jest.Mock).mockReturnValue(mockFileContent);
+
+      const result = nodeFileSystem.readFile(mockFilePath);
+
+      // Assert that fs.readFileSync was called with the correct file path and encoding
+      expect(fs.readFileSync).toHaveBeenCalledWith(mockFilePath, "utf8");
+
+      // Assert that the returned content matches the mock file content
+      expect(result).toBe(mockFileContent);
+    });
+  });
+
+  describe("writeFile", () => {
+    test("should call fs.writeFileSync with correct arguments", () => {
+      const mockFilePath = "test-file.txt";
+      const mockFileContent = "This is a test file";
+
+      // Call the writeFile method
+      nodeFileSystem.writeFile(mockFilePath, mockFileContent);
+
+      // Assert that fs.writeFileSync was called with the correct arguments
+      expect(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockFileContent, "utf8");
+    });
+  });
+
+  describe("readdirSync", () => {
+    test("should call fs.readdirSync with correct arguments and return file list", () => {
+      const mockDirectoryPath = "test-directory";
+      const mockFileList = ["file1.txt", "file2.txt"];
+
+      // Mock the fs.readdirSync method to return the mock file list
+      (fs.readdirSync as jest.Mock).mockReturnValue(mockFileList);
+
+      const result = nodeFileSystem.readdirSync(mockDirectoryPath);
+
+      // Assert that fs.readdirSync was called with the correct directory path
+      expect(fs.readdirSync).toHaveBeenCalledWith(mockDirectoryPath);
+
+      // Assert that the returned file list matches the mock file list
+      expect(result).toEqual(mockFileList);
+    });
+  });
+});

package/src/fileSystem.ts

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+
+import * as fs from "fs";
+
+export interface FileSystem {
+  readFile(filePath: string): string;
+  writeFile(filePath: string, content: string): void;
+  readdirSync(directory: string): string[];
+}
+
+/* eslint class-methods-use-this: "off" */
+export class NodeFileSystem implements FileSystem {
+  readFile(filePath: string): string {
+    return fs.readFileSync(filePath, "utf8");
+  }
+
+  writeFile(filePath: string, content: string): void {
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+
+  readdirSync(directory: string): string[] {
+    return fs.readdirSync(directory);
+  }
+}

package/src/fluent/watch.ts

@@ -4,12 +4,14 @@
 import byline from "byline";
 import { createHash } from "crypto";
 import { EventEmitter } from "events";
+import https from "https";
+import http2 from "http2";
 import fetch from "node-fetch";
-
 import { fetch as wrappedFetch } from "../fetch";
 import { GenericClass, KubernetesListObject } from "../types";
 import { Filters, WatchAction, WatchPhase } from "./types";
 import { k8sCfg, pathBuilder } from "./utils";
+import fs from "fs";
 
 export enum WatchEvent {
   /** Watch is connected successfully */
@@ -52,6 +54,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;
 };
 
 const NONE = 50;
@@ -65,6 +69,7 @@ export class Watcher<T extends GenericClass> {
   #callback: WatchAction<T>;
   #watchCfg: WatchCfg;
   #latestRelistWindow: string = "";
+  #useHTTP2: boolean = false;
 
   // Track the last time data was received
   #lastSeenTime = NONE;
@@ -97,6 +102,8 @@ export class Watcher<T extends GenericClass> {
   // Track the list of items in the cache
   #cache = new Map<string, InstanceType<T>>();
 
+  // Token Path
+  #TOKEN_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/token";
   /**
    * 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}.
@@ -125,6 +132,9 @@ export class Watcher<T extends GenericClass> {
     // 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);
 
@@ -158,7 +168,11 @@ export class Watcher<T extends GenericClass> {
    */
   public async start(): Promise<AbortController> {
     this.#events.emit(WatchEvent.INIT_CACHE_MISS, this.#latestRelistWindow);
-    await this.#watch();
+    if (this.#useHTTP2) {
+      await this.#http2Watch();
+    } else {
+      await this.#watch();
+    }
     return this.#abortController;
   }
 
@@ -198,6 +212,19 @@ export class Watcher<T extends GenericClass> {
     return this.#events;
   }
 
+  /**
+   * Read the serviceAccount Token
+   *
+   * @returns token or null
+   */
+  async #getToken() {
+    try {
+      return (await fs.promises.readFile(this.#TOKEN_PATH, "utf8")).trim();
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Build the URL and request options for the watch.
    *
@@ -351,6 +378,42 @@ export class Watcher<T extends GenericClass> {
     }
   };
 
+  // process a line from the chunk
+  #processLine = async (
+    line: string,
+    process: (payload: InstanceType<T>, phase: WatchPhase) => Promise<void>,
+  ) => {
+    try {
+      // Parse the event payload
+      const { object: payload, type: phase } = JSON.parse(line) as {
+        type: WatchPhase;
+        object: InstanceType<T>;
+      };
+
+      // Update the last seen time
+      this.#lastSeenTime = Date.now();
+
+      // If the watch is too old, remove the resourceVersion and reload the watch
+      if (phase === WatchPhase.Error && payload.code === 410) {
+        throw {
+          name: "TooOld",
+          message: this.#resourceVersion!,
+        };
+      }
+
+      // Process the event payload, do not update the resource version as that is handled by the list operation
+      await process(payload, phase);
+    } catch (err) {
+      if (err.name === "TooOld") {
+        // Reload the watch
+        void this.#errHandler(err);
+        return;
+      }
+
+      this.#events.emit(WatchEvent.DATA_ERROR, err);
+    }
+  };
+
   /**
    * Watch for changes to the resource.
    */
@@ -388,38 +451,7 @@ export class Watcher<T extends GenericClass> {
 
         // Listen for events and call the callback function
         this.#stream.on("data", async line => {
-          try {
-            // Parse the event payload
-            const { object: payload, type: phase } = JSON.parse(line) as {
-              type: WatchPhase;
-              object: InstanceType<T>;
-            };
-
-            // Update the last seen time
-            this.#lastSeenTime = Date.now();
-
-            // If the watch is too old, remove the resourceVersion and reload the watch
-            if (phase === WatchPhase.Error && payload.code === 410) {
-              throw {
-                name: "TooOld",
-                message: this.#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") {
-              // Prevent any body events from firing
-              body.removeAllListeners();
-
-              // Reload the watch
-              void this.#errHandler(err);
-              return;
-            }
-
-            this.#events.emit(WatchEvent.DATA_ERROR, err);
-          }
+          await this.#processLine(line, this.#process);
         });
 
         // Bind the body events
@@ -437,6 +469,108 @@ export class Watcher<T extends GenericClass> {
     }
   };
 
+  /**
+   * Watch for changes to the resource.
+   */
+  #http2Watch = 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);
+      let agentOptions;
+
+      if (opts.agent && opts.agent instanceof https.Agent) {
+        agentOptions = {
+          key: opts.agent.options.key,
+          cert: opts.agent.options.cert,
+          ca: opts.agent.options.ca,
+          rejectUnauthorized: false,
+        };
+      }
+
+      // HTTP/2 client connection setup
+      const client = http2.connect(url.origin, {
+        ca: agentOptions?.ca,
+        cert: agentOptions?.cert,
+        key: agentOptions?.key,
+        rejectUnauthorized: agentOptions?.rejectUnauthorized,
+      });
+
+      // Set up headers for the HTTP/2 request
+      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}`;
+      }
+
+      // Make the HTTP/2 request
+      const req = client.request(headers);
+
+      req.setEncoding("utf8");
+
+      let buffer = "";
+
+      // Handle response data
+      req.on("response", headers => {
+        const statusCode = headers[":status"];
+
+        if (statusCode && statusCode >= 200 && statusCode < 300) {
+          this.#pendingReconnect = false;
+          this.#events.emit(WatchEvent.CONNECT, url.pathname);
+
+          // Reset the retry count
+          this.#resyncFailureCount = 0;
+          this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
+
+          req.on("data", async chunk => {
+            try {
+              buffer += chunk;
+              const lines = buffer.split("\n");
+              // Avoid  Watch event data_error received. Unexpected end of JSON input.
+              buffer = lines.pop()!;
+
+              for (const line of lines) {
+                await this.#processLine(line, this.#process);
+              }
+            } catch (err) {
+              void this.#errHandler(err);
+            }
+          });
+
+          req.on("end", () => {
+            this.#streamCleanup();
+            client.close();
+          });
+
+          req.on("close", () => {
+            this.#streamCleanup();
+            client.close();
+          });
+
+          req.on("error", err => {
+            void this.#errHandler(err);
+            client.close();
+          });
+        } else {
+          const statusMessage = headers[":status-text"] || "Unknown";
+          throw new Error(`watch connect failed: ${statusCode} ${statusMessage}`);
+        }
+      });
+
+      req.end();
+    } catch (e) {
+      void this.#errHandler(e);
+    }
+  };
+
   /** Clear the resync timer and schedule a new one. */
   #checkResync = () => {
     // Ignore if the last seen time is not set
@@ -468,7 +602,9 @@ export class Watcher<T extends GenericClass> {
           this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
           this.#streamCleanup();
 
-          void this.#watch();
+          if (!this.#useHTTP2) {
+            void this.#watch();
+          }
         }
       } else {
         // Otherwise, call the finally function if it exists
@@ -516,5 +652,8 @@ export class Watcher<T extends GenericClass> {
       this.#stream.removeAllListeners();
       this.#stream.destroy();
     }
+    if (this.#useHTTP2) {
+      void this.#http2Watch();
+    }
   };
 }