pepr 0.34.1 → 0.35.0

package/package.json

@@ -13,7 +13,7 @@
     "/dist",
     "/src"
   ],
-  "version": "0.34.1",
+  "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.4.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/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.
@@ -273,6 +274,14 @@ When(a.ConfigMap)
   .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>(jokeURL, {
       headers: {