pepr 0.35.0 → 0.36.0

package/src/lib/types.ts

@@ -94,6 +94,7 @@ export type Binding = {
     namespaces: string[];
     labels: Record<string, string>;
     annotations: Record<string, string>;
+    deletionTimestamp: boolean;
   };
   readonly mutateCallback?: MutateAction<GenericClass, InstanceType<GenericClass>>;
   readonly validateCallback?: ValidateAction<GenericClass, InstanceType<GenericClass>>;
@@ -137,6 +138,8 @@ export type BindingFilter<T extends GenericClass> = CommonActionChain<T> & {
    * @param value
    */
   WithAnnotation: (key: string, value?: string) => BindingFilter<T>;
+  /** Only apply the action if the resource has a deletionTimestamp. */
+  WithDeletionTimestamp: () => BindingFilter<T>;
 };
 
 export type BindingWithName<T extends GenericClass> = BindingFilter<T> & {

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 { afterAll, beforeEach, beforeAll, describe, expect, it, jest } from "@jest/globals";
+import { afterAll, beforeEach, 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, queueRecordKey } from "./watch-processor";
+import { setupWatch, logEvent, queueKey, getOrCreateQueue } from "./watch-processor";
 import Log from "./logger";
 import { metricsCollector } from "./metrics";
 
@@ -40,6 +40,7 @@ describe("WatchProcessor", () => {
       bindings: [
         {
           isWatch: true,
+          isQueue: false,
           model: "someModel",
           filters: {},
           event: "Create",
@@ -93,8 +94,15 @@ describe("WatchProcessor", () => {
 
     capabilities.push({
       bindings: [
-        { isWatch: true, model: "someModel", filters: { name: "bleh" }, event: "Create", watchCallback: jest.fn() },
-        { isWatch: false, model: "someModel", filters: {}, event: "Create", watchCallback: jest.fn() },
+        {
+          isWatch: true,
+          isQueue: true,
+          model: "someModel",
+          filters: { name: "bleh" },
+          event: "Create",
+          watchCallback: jest.fn(),
+        },
+        { isWatch: false, isQueue: false, model: "someModel", filters: {}, event: "Create", watchCallback: jest.fn() },
       ],
     } as unknown as Capability);
 
@@ -321,133 +329,90 @@ describe("logEvent function", () => {
   });
 });
 
-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("queueKey", () => {
+  const withKindNsName = { kind: "Pod", metadata: { namespace: "my-ns", name: "my-name" } } as KubernetesObject;
+  const withKindNs = { kind: "Pod", metadata: { namespace: "my-ns" } } as KubernetesObject;
+  const withKindName = { kind: "Pod", metadata: { name: "my-name" } } as KubernetesObject;
+  const withNsName = { metadata: { namespace: "my-ns", name: "my-name" } } as KubernetesObject;
+  const withKind = { kind: "Pod" } as KubernetesObject;
+  const withNs = { metadata: { namespace: "my-ns" } } as KubernetesObject;
+  const withName = { metadata: { name: "my-name" } } as KubernetesObject;
+  const withNone = {} as KubernetesObject;
+
+  const original = process.env.PEPR_RECONCILE_STRATEGY;
+
+  it.each([
+    ["kind", withKindNsName, "Pod"],
+    ["kind", withKindNs, "Pod"],
+    ["kind", withKindName, "Pod"],
+    ["kind", withNsName, "UnknownKind"],
+    ["kind", withKind, "Pod"],
+    ["kind", withNs, "UnknownKind"],
+    ["kind", withName, "UnknownKind"],
+    ["kind", withNone, "UnknownKind"],
+    ["kindNs", withKindNsName, "Pod/my-ns"],
+    ["kindNs", withKindNs, "Pod/my-ns"],
+    ["kindNs", withKindName, "Pod/cluster-scoped"],
+    ["kindNs", withNsName, "UnknownKind/my-ns"],
+    ["kindNs", withKind, "Pod/cluster-scoped"],
+    ["kindNs", withNs, "UnknownKind/my-ns"],
+    ["kindNs", withName, "UnknownKind/cluster-scoped"],
+    ["kindNs", withNone, "UnknownKind/cluster-scoped"],
+    ["kindNsName", withKindNsName, "Pod/my-ns/my-name"],
+    ["kindNsName", withKindNs, "Pod/my-ns/Unnamed"],
+    ["kindNsName", withKindName, "Pod/cluster-scoped/my-name"],
+    ["kindNsName", withNsName, "UnknownKind/my-ns/my-name"],
+    ["kindNsName", withKind, "Pod/cluster-scoped/Unnamed"],
+    ["kindNsName", withNs, "UnknownKind/my-ns/Unnamed"],
+    ["kindNsName", withName, "UnknownKind/cluster-scoped/my-name"],
+    ["kindNsName", withNone, "UnknownKind/cluster-scoped/Unnamed"],
+    ["global", withKindNsName, "global"],
+    ["global", withKindNs, "global"],
+    ["global", withKindName, "global"],
+    ["global", withNsName, "global"],
+    ["global", withKind, "global"],
+    ["global", withNs, "global"],
+    ["global", withName, "global"],
+    ["global", withNone, "global"],
+  ])("PEPR_RECONCILE_STRATEGY='%s' over '%j' becomes '%s'", (strat, obj, key) => {
+    process.env.PEPR_RECONCILE_STRATEGY = strat;
+    expect(queueKey(obj)).toBe(key);
   });
 
-  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");
-    });
+  afterAll(() => {
+    process.env.PEPR_RECONCILE_STRATEGY = original;
+  });
+});
 
-    it("should handle objects with missing metadata", () => {
-      const obj: KubernetesObject = {
-        kind: "Pod",
-      };
+describe("getOrCreateQueue", () => {
+  it("creates a Queue instance on first call", () => {
+    const obj: KubernetesObject = {
+      kind: "queue",
+      metadata: {
+        name: "nm",
+        namespace: "ns",
+      },
+    };
 
-      expect(queueRecordKey(obj)).toBe("Pod/cluster-scoped");
-    });
+    const firstQueue = getOrCreateQueue(obj);
+    expect(firstQueue.label()).toBeDefined();
+  });
 
-    it("should handle objects with missing kind", () => {
-      const obj: KubernetesObject = {
-        metadata: {
-          name: "my-pod",
-          namespace: "my-namespace",
-        },
-      };
+  it("returns same Queue instance on subsequent calls", () => {
+    const obj: KubernetesObject = {
+      kind: "queue",
+      metadata: {
+        name: "nm",
+        namespace: "ns",
+      },
+    };
 
-      expect(queueRecordKey(obj)).toBe("UnknownKind/my-namespace");
-    });
+    const firstQueue = getOrCreateQueue(obj);
+    expect(firstQueue.label()).toBeDefined();
 
-    it("should handle completely empty objects", () => {
-      const obj: KubernetesObject = {};
+    const secondQueue = getOrCreateQueue(obj);
+    expect(secondQueue.label()).toBeDefined();
 
-      expect(queueRecordKey(obj)).toBe("UnknownKind/cluster-scoped");
-    });
+    expect(firstQueue).toBe(secondQueue);
   });
 });

package/src/lib/watch-processor.ts

@@ -9,18 +9,18 @@ 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>> = {};
+// stores Queue instances
+const queues: Record<string, Queue<KubernetesObject>> = {};
 
 /**
- * Get the key for a record in the queueRecord
+ * Get the key for an entry in the queues
  *
- * @param obj The object to get the key for
- * @returns The key for the object
+ * @param obj The object to derive a key from
+ * @returns The key to a Queue in the list of queues
  */
-export function queueRecordKey(obj: KubernetesObject) {
-  const options = ["singular", "sharded"]; // TODO : ts-type this fella
-  const d3fault = "singular";
+export function queueKey(obj: KubernetesObject) {
+  const options = ["kind", "kindNs", "kindNsName", "global"];
+  const d3fault = "kind";
 
   let strat = process.env.PEPR_RECONCILE_STRATEGY || d3fault;
   strat = options.includes(strat) ? strat : d3fault;
@@ -29,7 +29,21 @@ export function queueRecordKey(obj: KubernetesObject) {
   const kind = obj.kind ?? "UnknownKind";
   const name = obj.metadata?.name ?? "Unnamed";
 
-  return strat === "singular" ? `${kind}/${ns}` : `${kind}/${name}/${ns}`;
+  const lookup: Record<string, string> = {
+    kind: `${kind}`,
+    kindNs: `${kind}/${ns}`,
+    kindNsName: `${kind}/${ns}/${name}`,
+    global: "global",
+  };
+  return lookup[strat];
+}
+
+export function getOrCreateQueue(obj: KubernetesObject) {
+  const key = queueKey(obj);
+  if (!queues[key]) {
+    queues[key] = new Queue<KubernetesObject>(key);
+  }
+  return queues[key];
 }
 
 // Watch configuration
@@ -77,16 +91,16 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
   const phaseMatch: WatchPhase[] = eventToPhaseMap[binding.event] || eventToPhaseMap[Event.Any];
 
   // The watch callback is run when an object is received or dequeued
-
   Log.debug({ watchCfg }, "Effective WatchConfig");
-  const watchCallback = async (obj: KubernetesObject, type: WatchPhase) => {
+
+  const watchCallback = async (obj: KubernetesObject, phase: WatchPhase) => {
     // First, filter the object based on the phase
-    if (phaseMatch.includes(type)) {
+    if (phaseMatch.includes(phase)) {
       try {
         // Then, check if the object matches the filter
         const filterMatch = filterNoMatchReason(binding, obj, capabilityNamespaces);
         if (filterMatch === "") {
-          await binding.watchCallback?.(obj, type);
+          await binding.watchCallback?.(obj, phase);
         } else {
           Log.debug(filterMatch);
         }
@@ -97,26 +111,15 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
     }
   };
 
-  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));
+  const watcher = K8s(binding.model, binding.filters).Watch(async (obj, phase) => {
+    Log.debug(obj, `Watch event ${phase} received`);
 
-    // If the binding is a queue, enqueue the object
     if (binding.isQueue) {
-      await queue.enqueue(obj, type);
+      const queue = getOrCreateQueue(obj);
+      await queue.enqueue(obj, phase, watchCallback);
     } else {
-      // Otherwise, run the watch callback directly
-      await watchCallback(obj, type);
+      await watchCallback(obj, phase);
     }
   }, watchCfg);
 
@@ -160,8 +163,8 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[]) {
   }
 }
 
-export function logEvent(type: WatchEvent, message: string = "", obj?: KubernetesObject) {
-  const logMessage = `Watch event ${type} received${message ? `. ${message}.` : "."}`;
+export function logEvent(event: WatchEvent, message: string = "", obj?: KubernetesObject) {
+  const logMessage = `Watch event ${event} received${message ? `. ${message}.` : "."}`;
   if (obj) {
     Log.debug(obj, logMessage);
   } else {

package/src/sdk/sdk.test.ts

@@ -11,6 +11,7 @@ import { beforeEach, describe, it, jest } from "@jest/globals";
 import { GenericKind } from "kubernetes-fluent-client";
 import { K8s, kind } from "kubernetes-fluent-client";
 import { Mock } from "jest-mock";
+import { V1OwnerReference } from "@kubernetes/client-node";
 
 jest.mock("kubernetes-fluent-client", () => ({
   K8s: jest.fn(),
@@ -163,23 +164,55 @@ describe("writeEvent", () => {
 });
 
 describe("getOwnerRefFrom", () => {
-  it("should return the owner reference for the CRD", () => {
-    const cr = {
+  const customResource = {
+    apiVersion: "v1",
+    kind: "Package",
+    metadata: { name: "test", namespace: "default", uid: "1" },
+  };
+
+  const ownerRef = [
+    {
       apiVersion: "v1",
       kind: "Package",
-      metadata: { name: "test", namespace: "default", uid: "1" },
-    };
-    const ownerRef = getOwnerRefFrom(cr as GenericKind);
-    expect(ownerRef).toEqual([
-      {
-        apiVersion: "v1",
-        kind: "Package",
-        name: "test",
-        uid: "1",
-      },
-    ]);
+      name: "test",
+      uid: "1",
+    },
+  ];
+
+  const ownerRefWithController = ownerRef.map(item => ({
+    ...item,
+    controller: true,
+  }));
+  const ownerRefWithBlockOwnerDeletion = ownerRef.map(item => ({
+    ...item,
+    blockOwnerDeletion: false,
+  }));
+  const ownerRefWithAllFields = ownerRef.map(item => ({
+    ...item,
+    blockOwnerDeletion: true,
+    controller: false,
+  }));
+
+  test.each([
+    [true, false, ownerRefWithAllFields],
+    [false, undefined, ownerRefWithBlockOwnerDeletion],
+    [undefined, true, ownerRefWithController],
+    [undefined, undefined, ownerRef],
+  ])(
+    "should return owner reference for the CRD for combinations of V1OwnerReference fields - Optionals: blockOwnerDeletion (%s), controller (%s)",
+    (blockOwnerDeletion, controller, expected) => {
+      const result = getOwnerRefFrom(customResource, blockOwnerDeletion, controller);
+      expect(result).toStrictEqual(expected);
+    },
+  );
+
+  it("should support all defined fields in the V1OwnerReference type", () => {
+    const V1OwnerReferenceFieldCount = Object.getOwnPropertyNames(V1OwnerReference).length;
+    const result = getOwnerRefFrom(customResource, false, true);
+    expect(Object.keys(result[0]).length).toEqual(V1OwnerReferenceFieldCount);
   });
 });
+
 describe("sanitizeResourceName Fuzzing Tests", () => {
   test("should handle any random string input", () => {
     fc.assert(

package/src/sdk/sdk.ts

@@ -79,18 +79,27 @@ export async function writeEvent(
 
 /**
  * Get the owner reference for a custom resource
- * @param cr the custom resource to get the owner reference for
- * @returns the owner reference for the custom resource
+ * @param customResource the custom resource to get the owner reference for
+ * @param blockOwnerDeletion if true, AND if the owner has the "foregroundDeletion" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed.
+ * @param controller if true, this reference points to the managing controller.
+ * @returns the owner reference array for the custom resource
  */
-export function getOwnerRefFrom(cr: GenericKind): V1OwnerReference[] {
-  const { name, uid } = cr.metadata!;
+export function getOwnerRefFrom(
+  customResource: GenericKind,
+  blockOwnerDeletion?: boolean,
+  controller?: boolean,
+): V1OwnerReference[] {
+  const { apiVersion, kind, metadata } = customResource;
+  const { name, uid } = metadata!;
 
   return [
     {
-      apiVersion: cr.apiVersion!,
-      kind: cr.kind!,
+      apiVersion: apiVersion!,
+      kind: kind!,
       uid: uid!,
       name: name!,
+      ...(blockOwnerDeletion !== undefined && { blockOwnerDeletion }),
+      ...(controller !== undefined && { controller }),
     },
   ];
 }