pepr 0.34.0 → 0.35.0

package/package.json

@@ -13,7 +13,7 @@
     "/dist",
     "/src"
   ],
-  "version": "0.34.0",
+  "version": "0.35.0",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
   "scripts": {
@@ -38,22 +38,22 @@
     "format:fix": "eslint src --fix && prettier src --write"
   },
   "dependencies": {
-    "@types/ramda": "0.30.1",
+    "@types/ramda": "0.30.2",
     "express": "4.19.2",
     "fast-json-patch": "3.1.1",
     "json-pointer": "^0.6.2",
-    "kubernetes-fluent-client": "3.0.1",
+    "kubernetes-fluent-client": "3.0.2",
     "pino": "9.3.2",
     "pino-pretty": "11.2.2",
     "prom-client": "15.1.3",
     "ramda": "0.30.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "19.3.0",
-    "@commitlint/config-conventional": "19.2.2",
+    "@commitlint/cli": "19.4.1",
+    "@commitlint/config-conventional": "19.4.1",
     "@fast-check/jest": "^2.0.1",
     "@jest/globals": "29.7.0",
-    "@types/eslint": "9.6.0",
+    "@types/eslint": "9.6.1",
     "@types/express": "4.17.21",
     "@types/json-pointer": "^1.0.34",
     "@types/node": "22.x.x",
@@ -63,8 +63,8 @@
     "fast-check": "^3.19.0",
     "jest": "29.7.0",
     "js-yaml": "^4.1.0",
-    "nock": "13.5.4",
-    "ts-jest": "29.2.4"
+    "nock": "^13.5.4",
+    "ts-jest": "29.2.5"
   },
   "peerDependencies": {
     "@typescript-eslint/eslint-plugin": "7.18.0",

package/src/cli/init/templates.ts

@@ -58,6 +58,7 @@ export function genPkgJSON(opts: InitOptions, pgkVerOverride?: string) {
     },
     dependencies: {
       pepr: pgkVerOverride || version,
+      nock: "13.5.4",
     },
     devDependencies: {
       typescript,

package/src/lib/assets/helm.ts

@@ -90,15 +90,9 @@ export function watcherDeployTemplate(buildTimestamp: string) {
                   - /app/node_modules/pepr/dist/controller.js
                   - {{ .Values.hash }}
                 readinessProbe:
-                  httpGet:
-                    path: /healthz
-                    port: 3000
-                    scheme: HTTPS
+                  {{- toYaml .Values.watcher.readinessProbe | nindent 12 }}
                 livenessProbe:
-                  httpGet:
-                    path: /healthz
-                    port: 3000
-                    scheme: HTTPS
+                  {{- toYaml .Values.watcher.livenessProbe | nindent 12 }}
                 ports:
                   - containerPort: 3000
                 resources:
@@ -176,15 +170,9 @@ export function admissionDeployTemplate(buildTimestamp: string) {
                   - /app/node_modules/pepr/dist/controller.js
                   - {{ .Values.hash }}
                 readinessProbe:
-                  httpGet:
-                    path: /healthz
-                    port: 3000
-                    scheme: HTTPS
+                  {{- toYaml .Values.admission.readinessProbe | nindent 12 }}
                 livenessProbe:
-                  httpGet:
-                    path: /healthz
-                    port: 3000
-                    scheme: HTTPS
+                  {{- toYaml .Values.admission.livenessProbe | nindent 12 }}
                 ports:
                   - containerPort: 3000
                 resources:

package/src/lib/assets/pods.ts

@@ -111,6 +111,7 @@ export function watcher(assets: Assets, hash: string, buildTimestamp: string, im
                   port: 3000,
                   scheme: "HTTPS",
                 },
+                initialDelaySeconds: 10,
               },
               livenessProbe: {
                 httpGet: {
@@ -118,6 +119,7 @@ export function watcher(assets: Assets, hash: string, buildTimestamp: string, im
                   port: 3000,
                   scheme: "HTTPS",
                 },
+                initialDelaySeconds: 10,
               },
               ports: [
                 {
@@ -248,6 +250,7 @@ export function deployment(
                   port: 3000,
                   scheme: "HTTPS",
                 },
+                initialDelaySeconds: 10,
               },
               livenessProbe: {
                 httpGet: {
@@ -255,6 +258,7 @@ export function deployment(
                   port: 3000,
                   scheme: "HTTPS",
                 },
+                initialDelaySeconds: 10,
               },
               ports: [
                 {

package/src/lib/assets/yaml.ts

@@ -45,6 +45,22 @@ export async function overridesFile({ hash, name, image, config, apiToken }: Ass
         runAsNonRoot: true,
         fsGroup: 65532,
       },
+      readinessProbe: {
+        httpGet: {
+          path: "/healthz",
+          port: 3000,
+          scheme: "HTTPS",
+        },
+        initialDelaySeconds: 10,
+      },
+      livenessProbe: {
+        httpGet: {
+          path: "/healthz",
+          port: 3000,
+          scheme: "HTTPS",
+        },
+        initialDelaySeconds: 10,
+      },
       resources: {
         requests: {
           memory: "64Mi",
@@ -95,6 +111,22 @@ export async function overridesFile({ hash, name, image, config, apiToken }: Ass
         runAsNonRoot: true,
         fsGroup: 65532,
       },
+      readinessProbe: {
+        httpGet: {
+          path: "/healthz",
+          port: 3000,
+          scheme: "HTTPS",
+        },
+        initialDelaySeconds: 10,
+      },
+      livenessProbe: {
+        httpGet: {
+          path: "/healthz",
+          port: 3000,
+          scheme: "HTTPS",
+        },
+        initialDelaySeconds: 10,
+      },
       resources: {
         requests: {
           memory: "64Mi",

package/src/lib/controller/store.ts

@@ -152,8 +152,6 @@ export class PeprControllerStore {
           fillCache(name, "add", [key.slice(offset)], data[key]);
         }
       }
-
-      // await K8s(PeprStore, { namespace, name: this.#name }).Patch(payload);
     }
     await flushCache();
     this.#setupWatch();

package/src/lib/storage.test.ts

@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 
 import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-import { DataStore, Storage, v2StoreKey, stripV2Prefix } from "./storage";
+import { DataStore, Storage, v2StoreKey, v2UnescapedStoreKey, stripV2Prefix } from "./storage";
 import fc from "fast-check";
 
 describe("stripV2Prefix", () => {
@@ -27,6 +27,18 @@ describe("v2StoreKey", () => {
     }
   });
 });
+
+describe("v2UnescapedStoreKey", () => {
+  it("should prefix the key with v2", () => {
+    const keys = ["https://google.com", "sso-client-http://bin", "key3", "key4", "key5"];
+    const results = ["v2-https://google.com", "v2-sso-client-http://bin", "v2-key3", "v2-key4", "v2-key5"];
+
+    for (let i = 0; i < keys.length; i++) {
+      const result = v2UnescapedStoreKey(keys[i]);
+      expect(result).toEqual(results[i]);
+    }
+  });
+});
 describe("Storage with fuzzing and property-based tests", () => {
   let storage: Storage;
 
@@ -39,7 +51,7 @@ describe("Storage with fuzzing and property-based tests", () => {
     fc.assert(
       fc.property(fc.string(), fc.string(), (key, value) => {
         storage.setItem(key, value);
-        const mockData: DataStore = { [v2StoreKey(key)]: value };
+        const mockData: DataStore = { [v2UnescapedStoreKey(key)]: value };
         storage.receive(mockData);
         if (value === "") {
           expect(storage.getItem(key)).toBeNull();
@@ -75,7 +87,7 @@ describe("Storage with fuzzing and property-based tests", () => {
     fc.assert(
       fc.property(fc.string(), fc.string(), (key, value) => {
         storage.setItem(key, value);
-        const mockData: DataStore = { [v2StoreKey(key)]: value };
+        const mockData: DataStore = { [v2UnescapedStoreKey(key)]: value };
         storage.receive(mockData);
         if (value === "") {
           expect(storage.getItem(key)).toBeNull();
@@ -100,19 +112,20 @@ describe("Storage", () => {
     const key = "key1";
     storage.setItem(key, "value1");
 
-    expect(mockSender).toHaveBeenCalledWith("add", [v2StoreKey(key)], "value1");
+    expect(mockSender).toHaveBeenCalledWith("add", [v2UnescapedStoreKey(key)], "value1");
   });
 
   it("should set an item and wait", () => {
     const mockSender = jest.fn();
     storage.registerSender(mockSender);
     jest.useFakeTimers();
-    const key = "key1";
+    const keys = ["key1", "https://google.com", "sso-client-http://bin"];
 
-    // asserting on sender invocation rather than Promise so no need to wait
-    void storage.setItemAndWait(key, "value1");
+    keys.map(key => {
+      void storage.setItemAndWait(key, "value1");
+      expect(mockSender).toHaveBeenCalledWith("add", [v2StoreKey(key)], "value1");
+    });
 
-    expect(mockSender).toHaveBeenCalledWith("add", [v2StoreKey(key)], "value1");
     jest.useRealTimers();
   });
 
@@ -142,10 +155,10 @@ describe("Storage", () => {
     const mockSender = jest.fn();
     storage.registerSender(mockSender);
 
-    storage.receive({ key1: "value1", key2: "value2" });
+    storage.receive({ key1: "value1", key2: "value2", "sso-client-http://bin": "value3" });
     storage.clear();
 
-    expect(mockSender).toHaveBeenCalledWith("remove", ["key1", "key2"], undefined);
+    expect(mockSender).toHaveBeenCalledWith("remove", ["key1", "key2", "sso-client-http:~1~1bin"], undefined);
   });
 
   it("should get an item", () => {
@@ -153,7 +166,7 @@ describe("Storage", () => {
     const results = ["value1", null, "!", "was-here", "3f7dd007-568f-4f4a-bbac-2e6bfff93860", "your-machine", " "];
 
     keys.map((key, i) => {
-      const mockData: DataStore = { [v2StoreKey(key)]: results[i]! };
+      const mockData: DataStore = { [v2UnescapedStoreKey(key)]: results[i]! };
 
       storage.receive(mockData);
       const value = storage.getItem(keys[i]);

package/src/lib/storage.ts

@@ -17,6 +17,10 @@ export function v2StoreKey(key: string) {
   return `${STORE_VERSION_PREFIX}-${pointer.escape(key)}`;
 }
 
+export function v2UnescapedStoreKey(key: string) {
+  return `${STORE_VERSION_PREFIX}-${key}`;
+}
+
 export function stripV2Prefix(key: string) {
   return key.replace(/^v2-/, "");
 }
@@ -95,7 +99,7 @@ export class Storage implements PeprStore {
   };
 
   getItem = (key: string) => {
-    const result = this.#store[v2StoreKey(key)] || null;
+    const result = this.#store[v2UnescapedStoreKey(key)] || null;
     if (result !== null && typeof result !== "function" && typeof result !== "object") {
       return result;
     }
@@ -103,7 +107,10 @@ export class Storage implements PeprStore {
   };
 
   clear = () => {
-    this.#dispatchUpdate("remove", Object.keys(this.#store));
+    this.#dispatchUpdate(
+      "remove",
+      Object.keys(this.#store).map(key => pointer.escape(key)),
+    );
   };
 
   removeItem = (key: string) => {
@@ -124,9 +131,10 @@ export class Storage implements PeprStore {
    */
   setItemAndWait = (key: string, value: string) => {
     this.#dispatchUpdate("add", [v2StoreKey(key)], value);
+
     return new Promise<void>((resolve, reject) => {
       const unsubscribe = this.subscribe(data => {
-        if (data[`${v2StoreKey(key)}`] === value) {
+        if (data[`${v2UnescapedStoreKey(key)}`] === value) {
           unsubscribe();
           resolve();
         }
@@ -151,7 +159,7 @@ export class Storage implements PeprStore {
     this.#dispatchUpdate("remove", [v2StoreKey(key)]);
     return new Promise<void>((resolve, reject) => {
       const unsubscribe = this.subscribe(data => {
-        if (!Object.hasOwn(data, `${v2StoreKey(key)}`)) {
+        if (!Object.hasOwn(data, `${v2UnescapedStoreKey(key)}`)) {
           unsubscribe();
           resolve();
         }

package/src/lib/watch-processor.test.ts

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { afterAll, beforeEach, beforeAll, describe, expect, it, jest } from "@jest/globals";
 import { GenericClass, K8s, KubernetesObject, kind } from "kubernetes-fluent-client";
 import { K8sInit, WatchPhase } from "kubernetes-fluent-client/dist/fluent/types";
 import { WatchCfg, WatchEvent, Watcher } from "kubernetes-fluent-client/dist/fluent/watch";
 import { Capability } from "./capability";
-import { setupWatch, logEvent } from "./watch-processor";
+import { setupWatch, logEvent, queueRecordKey } from "./watch-processor";
 import Log from "./logger";
 import { metricsCollector } from "./metrics";
 
@@ -88,7 +88,7 @@ describe("WatchProcessor", () => {
       resyncFailureMax: 5,
       resyncDelaySec: 5,
       lastSeenLimitSeconds: 300,
-      relistIntervalSec: 1800,
+      relistIntervalSec: 600,
     };
 
     capabilities.push({
@@ -320,3 +320,134 @@ describe("logEvent function", () => {
     expect(Log.debug).toHaveBeenCalledWith(`Watch event ${WatchEvent.DATA_ERROR} received. ${message}.`);
   });
 });
+
+describe("queueRecordKey", () => {
+  describe("PEPR_RECONCILE_STRATEGY=sharded", () => {
+    const original = process.env.PEPR_RECONCILE_STRATEGY;
+
+    beforeAll(() => {
+      process.env.PEPR_RECONCILE_STRATEGY = "sharded";
+    });
+    afterAll(() => {
+      process.env.PEPR_RECONCILE_STRATEGY = original;
+    });
+
+    it("should return correct key for an object with 'kind/name/namespace'", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+        metadata: {
+          name: "my-pod",
+          namespace: "my-namespace",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/my-pod/my-namespace");
+    });
+
+    it("should handle objects with missing namespace", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+        metadata: {
+          name: "my-pod",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/my-pod/cluster-scoped");
+    });
+
+    it("should handle objects with missing name", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+        metadata: {
+          namespace: "my-namespace",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/Unnamed/my-namespace");
+    });
+
+    it("should handle objects with missing metadata", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/Unnamed/cluster-scoped");
+    });
+
+    it("should handle objects with missing kind", () => {
+      const obj: KubernetesObject = {
+        metadata: {
+          name: "my-pod",
+          namespace: "my-namespace",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("UnknownKind/my-pod/my-namespace");
+    });
+
+    it("should handle completely empty objects", () => {
+      const obj: KubernetesObject = {};
+
+      expect(queueRecordKey(obj)).toBe("UnknownKind/Unnamed/cluster-scoped");
+    });
+  });
+
+  describe("PEPR_RECONCILE_STRATEGY=singular", () => {
+    const original = process.env.PEPR_RECONCILE_STRATEGY;
+
+    beforeAll(() => {
+      process.env.PEPR_RECONCILE_STRATEGY = "singular";
+    });
+    afterAll(() => {
+      process.env.PEPR_RECONCILE_STRATEGY = original;
+    });
+
+    it("should return correct key for an object with 'kind/namespace'", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+        metadata: {
+          name: "my-pod",
+          namespace: "my-namespace",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/my-namespace");
+    });
+
+    it("should handle objects with missing namespace", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+        metadata: {
+          name: "my-pod",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/cluster-scoped");
+    });
+
+    it("should handle objects with missing metadata", () => {
+      const obj: KubernetesObject = {
+        kind: "Pod",
+      };
+
+      expect(queueRecordKey(obj)).toBe("Pod/cluster-scoped");
+    });
+
+    it("should handle objects with missing kind", () => {
+      const obj: KubernetesObject = {
+        metadata: {
+          name: "my-pod",
+          namespace: "my-namespace",
+        },
+      };
+
+      expect(queueRecordKey(obj)).toBe("UnknownKind/my-namespace");
+    });
+
+    it("should handle completely empty objects", () => {
+      const obj: KubernetesObject = {};
+
+      expect(queueRecordKey(obj)).toBe("UnknownKind/cluster-scoped");
+    });
+  });
+});

package/src/lib/watch-processor.ts

@@ -9,6 +9,29 @@ import { Queue } from "./queue";
 import { Binding, Event } from "./types";
 import { metricsCollector } from "./metrics";
 
+// init a queueRecord record to store Queue instances for a given Kubernetes Object
+const queueRecord: Record<string, Queue<KubernetesObject>> = {};
+
+/**
+ * Get the key for a record in the queueRecord
+ *
+ * @param obj The object to get the key for
+ * @returns The key for the object
+ */
+export function queueRecordKey(obj: KubernetesObject) {
+  const options = ["singular", "sharded"]; // TODO : ts-type this fella
+  const d3fault = "singular";
+
+  let strat = process.env.PEPR_RECONCILE_STRATEGY || d3fault;
+  strat = options.includes(strat) ? strat : d3fault;
+
+  const ns = obj.metadata?.namespace ?? "cluster-scoped";
+  const kind = obj.kind ?? "UnknownKind";
+  const name = obj.metadata?.name ?? "Unnamed";
+
+  return strat === "singular" ? `${kind}/${ns}` : `${kind}/${name}/${ns}`;
+}
+
 // Watch configuration
 const watchCfg: WatchCfg = {
   resyncFailureMax: process.env.PEPR_RESYNC_FAILURE_MAX ? parseInt(process.env.PEPR_RESYNC_FAILURE_MAX, 10) : 5,
@@ -18,7 +41,7 @@ const watchCfg: WatchCfg = {
     : 300,
   relistIntervalSec: process.env.PEPR_RELIST_INTERVAL_SECONDS
     ? parseInt(process.env.PEPR_RELIST_INTERVAL_SECONDS, 10)
-    : 1800,
+    : 600,
 };
 
 // Map the event to the watch phase
@@ -74,13 +97,20 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
     }
   };
 
-  const queue = new Queue();
-  queue.setReconcile(watchCallback);
+  function getOrCreateQueue(key: string): Queue<KubernetesObject> {
+    if (!queueRecord[key]) {
+      queueRecord[key] = new Queue<KubernetesObject>();
+      queueRecord[key].setReconcile(watchCallback);
+    }
+    return queueRecord[key];
+  }
 
   // Setup the resource watch
   const watcher = K8s(binding.model, binding.filters).Watch(async (obj, type) => {
     Log.debug(obj, `Watch event ${type} received`);
 
+    const queue = getOrCreateQueue(queueRecordKey(obj));
+
     // If the binding is a queue, enqueue the object
     if (binding.isQueue) {
       await queue.enqueue(obj, type);

package/src/templates/capabilities/hello-pepr.ts

@@ -9,6 +9,7 @@ import {
   fetchStatus,
   kind,
 } from "pepr";
+import nock from "nock";
 
 /**
  *  The HelloPepr Capability is an example capability to demonstrate some general concepts of Pepr.
@@ -268,24 +269,47 @@ interface TheChuckNorrisJoke {
 }
 
 When(a.ConfigMap)
-  .IsCreated()
+  .IsCreatedOrUpdated()
   .WithLabel("chuck-norris")
-  .Mutate(async change => {
+  .Mutate(cm => cm.SetLabel("got-jokes", "true"))
+  .Watch(async cm => {
+    const jokeURL = "https://icanhazdadjoke.com/";
+
+    // Set up Nock to mock the API calls globally with header matching
+    nock(jokeURL).get("/").reply(200, {
+      id: "R7UfaahVfFd",
+      joke: "Funny joke goes here.",
+      status: 200,
+    });
+
     // Try/catch is not needed as a response object will always be returned
-    const response = await fetch<TheChuckNorrisJoke>(
-      "https://icanhazdadjoke.com/",
-      {
-        headers: {
-          Accept: "application/json",
-        },
+    const response = await fetch<TheChuckNorrisJoke>(jokeURL, {
+      headers: {
+        Accept: "application/json",
       },
-    );
+    });
 
     // Instead, check the `response.ok` field
     if (response.ok) {
+      const { joke } = response.data;
+      // Add Joke to the Store
+      await Store.setItemAndWait(jokeURL, joke);
       // Add the Chuck Norris joke to the configmap
-      change.Raw.data["chuck-says"] = response.data.joke;
-      return;
+      try {
+        await K8s(kind.ConfigMap).Apply({
+          metadata: {
+            name: cm.metadata.name,
+            namespace: cm.metadata.namespace,
+          },
+          data: {
+            "chuck-says": Store.getItem(jokeURL),
+          },
+        });
+      } catch (error) {
+        Log.error(error, "Failed to apply ConfigMap using server-side apply.", {
+          cm,
+        });
+      }
     }
 
     // You can also assert on different HTTP response codes