pepr 0.34.1 → 0.36.0

package/dist/lib.js

@@ -244,6 +244,12 @@ function shouldSkipRequest(binding, req, capabilityNamespaces) {
   const srcObject = operation === "DELETE" /* DELETE */ ? req.oldObject : req.object;
   const { metadata } = srcObject || {};
   const combinedNamespaces = [...namespaces, ...capabilityNamespaces];
+  if (binding.event.includes("DELETE" /* Delete */) && binding.filters?.deletionTimestamp) {
+    return true;
+  }
+  if (binding.filters?.deletionTimestamp && !req.object.metadata?.deletionTimestamp) {
+    return true;
+  }
   if (!binding.event.includes(operation) && !binding.event.includes("*" /* Any */)) {
     return true;
   }
@@ -1154,14 +1160,17 @@ async function writeEvent(cr, event, eventType, eventReason, reportingComponent,
     reportingInstance
   });
 }
-function getOwnerRefFrom(cr) {
-  const { name, uid } = cr.metadata;
+function getOwnerRefFrom(customResource, blockOwnerDeletion, controller) {
+  const { apiVersion, kind: kind4, metadata } = customResource;
+  const { name, uid } = metadata;
   return [
     {
-      apiVersion: cr.apiVersion,
-      kind: cr.kind,
+      apiVersion,
+      kind: kind4,
       uid,
-      name
+      name,
+      ...blockOwnerDeletion !== void 0 && { blockOwnerDeletion },
+      ...controller !== void 0 && { controller }
     }
   ];
 }
@@ -1189,6 +1198,9 @@ function checkOverlap(bindingFilters, objectFilters) {
   return matchCount === Object.keys(bindingFilters).length;
 }
 function filterNoMatchReason(binding, obj, capabilityNamespaces) {
+  if (binding.filters?.deletionTimestamp && !obj.metadata?.deletionTimestamp) {
+    return `Ignoring Watch Callback: Object does not have a deletion timestamp.`;
+  }
   if (binding.kind && binding.kind.kind === "Namespace" && binding.filters && binding.filters.namespaces.length !== 0) {
     return `Ignoring Watch Callback: Cannot use a namespace filter in a namespace object.`;
   }
@@ -1223,27 +1235,49 @@ function filterNoMatchReason(binding, obj, capabilityNamespaces) {
 }
 
 // src/lib/queue.ts
+var import_node_crypto = require("node:crypto");
 var Queue = class {
+  #name;
+  #uid;
   #queue = [];
   #pendingPromise = false;
-  #reconcile;
-  constructor() {
-    this.#reconcile = async () => await new Promise((resolve) => resolve());
+  constructor(name) {
+    this.#name = name;
+    this.#uid = `${Date.now()}-${(0, import_node_crypto.randomBytes)(2).toString("hex")}`;
   }
-  setReconcile(reconcile) {
-    this.#reconcile = reconcile;
+  label() {
+    return { name: this.#name, uid: this.#uid };
+  }
+  stats() {
+    return {
+      queue: this.label(),
+      stats: {
+        length: this.#queue.length
+      }
+    };
   }
   /**
    * Enqueue adds an item to the queue and returns a promise that resolves when the item is
    * reconciled.
    *
    * @param item The object to reconcile
+   * @param type The watch phase requested for reconcile
+   * @param reconcile The callback to enqueue for reconcile
    * @returns A promise that resolves when the object is reconciled
    */
-  enqueue(item, type) {
-    logger_default.debug(`Enqueueing ${item.metadata.namespace}/${item.metadata.name}`);
+  enqueue(item, phase, reconcile) {
+    const note = {
+      queue: this.label(),
+      item: {
+        name: item.metadata?.name,
+        namespace: item.metadata?.namespace,
+        resourceVersion: item.metadata?.resourceVersion
+      }
+    };
+    logger_default.debug(note, "Enqueueing");
     return new Promise((resolve, reject) => {
-      this.#queue.push({ item, type, resolve, reject });
+      this.#queue.push({ item, phase, callback: reconcile, resolve, reject });
+      logger_default.debug(this.stats(), "Queue stats - push");
       return this.#dequeue();
     });
   }
@@ -1264,15 +1298,23 @@ var Queue = class {
     }
     try {
       this.#pendingPromise = true;
-      if (this.#reconcile) {
-        logger_default.debug(`Reconciling ${element.item.metadata.name}`);
-        await this.#reconcile(element.item, element.type);
-      }
+      const note = {
+        queue: this.label(),
+        item: {
+          name: element.item.metadata?.name,
+          namespace: element.item.metadata?.namespace,
+          resourceVersion: element.item.metadata?.resourceVersion
+        }
+      };
+      logger_default.debug(note, "Reconciling");
+      await element.callback(element.item, element.phase);
+      logger_default.debug(note, "Reconciled");
       element.resolve();
     } catch (e) {
       logger_default.debug(`Error reconciling ${element.item.metadata.name}`, { error: e });
       element.reject(e);
     } finally {
+      logger_default.debug(this.stats(), "Queue stats - shift");
       logger_default.debug("Resetting pending promise and dequeuing");
       this.#pendingPromise = false;
       await this.#dequeue();
@@ -1281,11 +1323,35 @@ var Queue = class {
 };
 
 // src/lib/watch-processor.ts
+var queues = {};
+function queueKey(obj) {
+  const options = ["kind", "kindNs", "kindNsName", "global"];
+  const d3fault = "kind";
+  let strat = process.env.PEPR_RECONCILE_STRATEGY || d3fault;
+  strat = options.includes(strat) ? strat : d3fault;
+  const ns = obj.metadata?.namespace ?? "cluster-scoped";
+  const kind4 = obj.kind ?? "UnknownKind";
+  const name = obj.metadata?.name ?? "Unnamed";
+  const lookup = {
+    kind: `${kind4}`,
+    kindNs: `${kind4}/${ns}`,
+    kindNsName: `${kind4}/${ns}/${name}`,
+    global: "global"
+  };
+  return lookup[strat];
+}
+function getOrCreateQueue(obj) {
+  const key = queueKey(obj);
+  if (!queues[key]) {
+    queues[key] = new Queue(key);
+  }
+  return queues[key];
+}
 var watchCfg = {
   resyncFailureMax: process.env.PEPR_RESYNC_FAILURE_MAX ? parseInt(process.env.PEPR_RESYNC_FAILURE_MAX, 10) : 5,
   resyncDelaySec: process.env.PEPR_RESYNC_DELAY_SECONDS ? parseInt(process.env.PEPR_RESYNC_DELAY_SECONDS, 10) : 5,
   lastSeenLimitSeconds: process.env.PEPR_LAST_SEEN_LIMIT_SECONDS ? parseInt(process.env.PEPR_LAST_SEEN_LIMIT_SECONDS, 10) : 300,
-  relistIntervalSec: process.env.PEPR_RELIST_INTERVAL_SECONDS ? parseInt(process.env.PEPR_RELIST_INTERVAL_SECONDS, 10) : 1800
+  relistIntervalSec: process.env.PEPR_RELIST_INTERVAL_SECONDS ? parseInt(process.env.PEPR_RELIST_INTERVAL_SECONDS, 10) : 600
 };
 var eventToPhaseMap = {
   ["CREATE" /* Create */]: [import_types2.WatchPhase.Added],
@@ -1302,12 +1368,12 @@ function setupWatch(capabilities) {
 async function runBinding(binding, capabilityNamespaces) {
   const phaseMatch = eventToPhaseMap[binding.event] || eventToPhaseMap["*" /* Any */];
   logger_default.debug({ watchCfg }, "Effective WatchConfig");
-  const watchCallback = async (obj, type) => {
-    if (phaseMatch.includes(type)) {
+  const watchCallback = async (obj, phase) => {
+    if (phaseMatch.includes(phase)) {
       try {
         const filterMatch = filterNoMatchReason(binding, obj, capabilityNamespaces);
         if (filterMatch === "") {
-          await binding.watchCallback?.(obj, type);
+          await binding.watchCallback?.(obj, phase);
         } else {
           logger_default.debug(filterMatch);
         }
@@ -1316,14 +1382,13 @@ async function runBinding(binding, capabilityNamespaces) {
       }
     }
   };
-  const queue = new Queue();
-  queue.setReconcile(watchCallback);
-  const watcher = (0, import_kubernetes_fluent_client5.K8s)(binding.model, binding.filters).Watch(async (obj, type) => {
-    logger_default.debug(obj, `Watch event ${type} received`);
+  const watcher = (0, import_kubernetes_fluent_client5.K8s)(binding.model, binding.filters).Watch(async (obj, phase) => {
+    logger_default.debug(obj, `Watch event ${phase} received`);
     if (binding.isQueue) {
-      await queue.enqueue(obj, type);
+      const queue = getOrCreateQueue(obj);
+      await queue.enqueue(obj, phase, watchCallback);
     } else {
-      await watchCallback(obj, type);
+      await watchCallback(obj, phase);
     }
   }, watchCfg);
   watcher.events.on(import_kubernetes_fluent_client5.WatchEvent.GIVE_UP, (err) => {
@@ -1359,8 +1424,8 @@ async function runBinding(binding, capabilityNamespaces) {
     process.exit(1);
   }
 }
-function logEvent(type, message = "", obj) {
-  const logMessage = `Watch event ${type} received${message ? `. ${message}.` : "."}`;
+function logEvent(event, message = "", obj) {
+  const logMessage = `Watch event ${event} received${message ? `. ${message}.` : "."}`;
   if (obj) {
     logger_default.debug(obj, logMessage);
   } else {
@@ -1824,12 +1889,13 @@ var Capability = class {
         name: "",
         namespaces: [],
         labels: {},
-        annotations: {}
+        annotations: {},
+        deletionTimestamp: false
       }
     };
     const bindings = this.#bindings;
     const prefix = `${this.#name}: ${model.name}`;
-    const commonChain = { WithLabel, WithAnnotation, Mutate, Validate, Watch, Reconcile };
+    const commonChain = { WithLabel, WithAnnotation, WithDeletionTimestamp, Mutate, Validate, Watch, Reconcile };
     const isNotEmpty = (value) => Object.keys(value).length > 0;
     const log = (message, cbString) => {
       const filteredObj = (0, import_ramda6.pickBy)(isNotEmpty, binding.filters);
@@ -1885,6 +1951,11 @@ var Capability = class {
       binding.filters.namespaces.push(...namespaces);
       return { ...commonChain, WithName };
     }
+    function WithDeletionTimestamp() {
+      logger_default.debug("Add deletionTimestamp filter");
+      binding.filters.deletionTimestamp = true;
+      return commonChain;
+    }
     function WithName(name) {
       logger_default.debug(`Add name filter ${name}`, prefix);
       binding.filters.name = name;
@@ -1905,7 +1976,8 @@ var Capability = class {
       return {
         ...commonChain,
         InNamespace,
-        WithName
+        WithName,
+        WithDeletionTimestamp
       };
     }
     return {