pepr 0.27.0 → 0.28.1

package/dist/lib.js

@@ -31,26 +31,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var lib_exports = {};
 __export(lib_exports, {
   Capability: () => Capability,
-  K8s: () => import_kubernetes_fluent_client5.K8s,
+  K8s: () => import_kubernetes_fluent_client6.K8s,
   Log: () => logger_default,
   PeprModule: () => PeprModule,
   PeprMutateRequest: () => PeprMutateRequest,
   PeprUtils: () => utils_exports,
   PeprValidateRequest: () => PeprValidateRequest,
   R: () => R,
-  RegisterKind: () => import_kubernetes_fluent_client5.RegisterKind,
-  a: () => import_kubernetes_fluent_client5.kind,
+  RegisterKind: () => import_kubernetes_fluent_client6.RegisterKind,
+  a: () => import_kubernetes_fluent_client6.kind,
   containers: () => containers,
-  fetch: () => import_kubernetes_fluent_client5.fetch,
-  fetchStatus: () => import_kubernetes_fluent_client5.fetchStatus,
-  kind: () => import_kubernetes_fluent_client5.kind
+  fetch: () => import_kubernetes_fluent_client6.fetch,
+  fetchStatus: () => import_kubernetes_fluent_client6.fetchStatus,
+  kind: () => import_kubernetes_fluent_client6.kind
 });
 module.exports = __toCommonJS(lib_exports);
-var import_kubernetes_fluent_client5 = require("kubernetes-fluent-client");
+var import_kubernetes_fluent_client6 = require("kubernetes-fluent-client");
 var R = __toESM(require("ramda"));
 
 // src/lib/capability.ts
-var import_kubernetes_fluent_client4 = require("kubernetes-fluent-client");
+var import_kubernetes_fluent_client5 = require("kubernetes-fluent-client");
 var import_ramda6 = require("ramda");
 
 // src/lib/logger.ts
@@ -187,7 +187,7 @@ var peprStoreGVK = {
 
 // src/lib/filter.ts
 function shouldSkipRequest(binding, req, capabilityNamespaces) {
-  const { group, kind: kind2, version } = binding.kind || {};
+  const { group, kind: kind3, version } = binding.kind || {};
   const { namespaces, labels, annotations, name } = binding.filters || {};
   const operation = req.operation.toUpperCase();
   const srcObject = operation === "DELETE" /* DELETE */ ? req.oldObject : req.object;
@@ -199,7 +199,7 @@ function shouldSkipRequest(binding, req, capabilityNamespaces) {
   if (name && name !== req.name) {
     return true;
   }
-  if (kind2 !== req.kind.kind) {
+  if (kind3 !== req.kind.kind) {
     return true;
   }
   if (group && group !== req.kind.group) {
@@ -668,7 +668,7 @@ var PeprControllerStore = class {
       }
     };
     clearTimeout(this.#sendDebounce);
-    this.#sendDebounce = setTimeout(debounced, debounceBackoff);
+    this.#sendDebounce = setTimeout(debounced, this.#onReady ? 0 : debounceBackoff);
   };
   #send = (capabilityName) => {
     const sendCache = {};
@@ -969,7 +969,7 @@ var Controller = class _Controller {
 
 // src/lib/watch-processor.ts
 var import_crypto = require("crypto");
-var import_kubernetes_fluent_client3 = require("kubernetes-fluent-client");
+var import_kubernetes_fluent_client4 = require("kubernetes-fluent-client");
 var import_types2 = require("kubernetes-fluent-client/dist/fluent/types");
 
 // src/lib/queue.ts
@@ -1023,39 +1023,61 @@ var Queue = class {
   }
 };
 
-// src/lib/watch-processor.ts
-var storeUpdates = false;
-var store = {};
-async function setupStore(uuid) {
-  const name = `pepr-${uuid}-watch`;
-  const namespace2 = "pepr-system";
-  try {
-    const k8sStore = await (0, import_kubernetes_fluent_client3.K8s)(PeprStore).InNamespace(namespace2).Get(name);
-    Object.entries(k8sStore.data).forEach(([key, value]) => {
-      store[key] = value;
-    });
-  } catch (e) {
-    logger_default.debug(e, "Watch store does not exist yet");
+// src/lib/helpers.ts
+var import_kubernetes_fluent_client3 = require("kubernetes-fluent-client");
+function checkOverlap(record1, record2) {
+  if (Object.keys(record1).length === 0) {
+    return true;
   }
-  setInterval(() => {
-    if (storeUpdates) {
-      (0, import_kubernetes_fluent_client3.K8s)(PeprStore).Apply({
-        metadata: {
-          name,
-          namespace: namespace2
-        },
-        data: store
-      }).then(() => storeUpdates = false).catch((e) => {
-        logger_default.error(e, "Error updating watch store");
-      });
+  for (const key in record1) {
+    if (Object.prototype.hasOwnProperty.call(record1, key) && Object.prototype.hasOwnProperty.call(record2, key) && record1[key] === record2[key]) {
+      return true;
     }
-  }, 10 * 1e3);
+  }
+  return false;
 }
-async function setupWatch(uuid, capabilities) {
-  await setupStore(uuid);
-  capabilities.flatMap((c) => c.bindings).filter((binding) => binding.isWatch).forEach(runBinding);
+var filterMatcher = (binding, obj, capabilityNamespaces) => {
+  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.`;
+  }
+  if (typeof obj === "object" && obj !== null && "metadata" in obj && obj.metadata !== void 0 && binding.filters) {
+    if (obj.metadata.labels && !checkOverlap(binding.filters.labels, obj.metadata.labels)) {
+      return `Ignoring Watch Callback: No overlap between binding and object labels. Binding labels ${JSON.stringify(
+        binding.filters.labels
+      )}, Object Labels ${JSON.stringify(obj.metadata.labels)}.`;
+    }
+    if (obj.metadata.annotations && !checkOverlap(binding.filters.annotations, obj.metadata.annotations)) {
+      return `Ignoring Watch Callback: No overlap between binding and object annotations. Binding annotations ${JSON.stringify(
+        binding.filters.annotations
+      )}, Object annotations ${JSON.stringify(obj.metadata.annotations)}.`;
+    }
+  }
+  if (Array.isArray(capabilityNamespaces) && capabilityNamespaces.length > 0 && obj.metadata && obj.metadata.namespace && !capabilityNamespaces.includes(obj.metadata.namespace)) {
+    return `Ignoring Watch Callback: Object is not in the capability namespace. Capability namespaces: ${capabilityNamespaces.join(
+      ", "
+    )}, Object namespace: ${obj.metadata.namespace}.`;
+  }
+  if (Array.isArray(capabilityNamespaces) && capabilityNamespaces.length > 0 && binding.filters && Array.isArray(binding.filters.namespaces) && binding.filters.namespaces.length > 0 && !binding.filters.namespaces.every((ns) => capabilityNamespaces.includes(ns))) {
+    return `Ignoring Watch Callback: Binding namespace is not part of capability namespaces. Capability namespaces: ${capabilityNamespaces.join(
+      ", "
+    )}, Binding namespaces: ${binding.filters.namespaces.join(", ")}.`;
+  }
+  if (binding.filters && Array.isArray(binding.filters.namespaces) && binding.filters.namespaces.length > 0 && obj.metadata && obj.metadata.namespace && !binding.filters.namespaces.includes(obj.metadata.namespace)) {
+    return `Ignoring Watch Callback: Binding namespace and object namespace are not the same. Binding namespaces: ${binding.filters.namespaces.join(
+      ", "
+    )}, Object namespace: ${obj.metadata.namespace}.`;
+  }
+  return "";
+};
+
+// src/lib/watch-processor.ts
+var store = {};
+function setupWatch(capabilities) {
+  capabilities.map(
+    (capability) => capability.bindings.filter((binding) => binding.isWatch).forEach((bindingElement) => runBinding(bindingElement, capability.namespaces))
+  );
 }
-async function runBinding(binding) {
+async function runBinding(binding, capabilityNamespaces) {
   const eventToPhaseMap = {
     ["CREATE" /* Create */]: [import_types2.WatchPhase.Added],
     ["UPDATE" /* Update */]: [import_types2.WatchPhase.Modified],
@@ -1071,23 +1093,33 @@ async function runBinding(binding) {
   let watcher;
   if (binding.isQueue) {
     const queue = new Queue();
-    watcher = (0, import_kubernetes_fluent_client3.K8s)(binding.model, binding.filters).Watch(async (obj, type) => {
+    watcher = (0, import_kubernetes_fluent_client4.K8s)(binding.model, binding.filters).Watch(async (obj, type) => {
       logger_default.debug(obj, `Watch event ${type} received`);
       if (phaseMatch.includes(type)) {
         try {
-          queue.setReconcile(async () => await binding.watchCallback?.(obj, type));
-          await queue.enqueue(obj);
+          const filterMatch = filterMatcher(binding, obj, capabilityNamespaces);
+          if (filterMatch === "") {
+            queue.setReconcile(async () => await binding.watchCallback?.(obj, type));
+            await queue.enqueue(obj);
+          } else {
+            logger_default.debug(filterMatch);
+          }
         } catch (e) {
           logger_default.error(e, "Error executing watch callback");
         }
       }
     }, watchCfg);
   } else {
-    watcher = (0, import_kubernetes_fluent_client3.K8s)(binding.model, binding.filters).Watch(async (obj, type) => {
+    watcher = (0, import_kubernetes_fluent_client4.K8s)(binding.model, binding.filters).Watch(async (obj, type) => {
       logger_default.debug(obj, `Watch event ${type} received`);
       if (phaseMatch.includes(type)) {
         try {
-          await binding.watchCallback?.(obj, type);
+          const filterMatch = filterMatcher(binding, obj, capabilityNamespaces);
+          if (filterMatch === "") {
+            await binding.watchCallback?.(obj, type);
+          } else {
+            logger_default.debug(filterMatch);
+          }
         } catch (e) {
           logger_default.error(e, "Error executing watch callback");
         }
@@ -1096,15 +1128,7 @@ async function runBinding(binding) {
   }
   const cacheSuffix = (0, import_crypto.createHash)("sha224").update(binding.watchCallback.toString()).digest("hex").substring(0, 5);
   const cacheID = [watcher.getCacheID(), cacheSuffix].join("-");
-  watcher.events.on(import_kubernetes_fluent_client3.WatchEvent.RESOURCE_VERSION, (version) => {
-    logger_default.debug(`Received watch cache: ${cacheID}:${version}`);
-    if (store[cacheID] !== version) {
-      logger_default.debug(`Updating watch cache: ${cacheID}: ${store[cacheID]} => ${version}`);
-      store[cacheID] = version;
-      storeUpdates = true;
-    }
-  });
-  watcher.events.on(import_kubernetes_fluent_client3.WatchEvent.GIVE_UP, (err) => {
+  watcher.events.on(import_kubernetes_fluent_client4.WatchEvent.GIVE_UP, (err) => {
     logger_default.error(err, "Watch failed after 5 attempts, giving up");
     process.exit(1);
   });
@@ -1157,10 +1181,12 @@ var PeprModule = class {
     }
     this.#controller = new Controller(config, capabilities, opts.beforeHook, opts.afterHook, () => {
       if (isWatchMode() || isDevMode()) {
-        setupWatch(config.uuid, capabilities).catch((e) => {
+        try {
+          setupWatch(capabilities);
+        } catch (e) {
           logger_default.error(e, "Error setting up watch");
           process.exit(1);
-        });
+        }
       }
     });
     if (opts.deferStart) {
@@ -1547,15 +1573,15 @@ var Capability = class {
    * @param kind if using a custom KubernetesObject not available in `a.*`, specify the GroupVersionKind
    * @returns
    */
-  When = (model, kind2) => {
-    const matchedKind = (0, import_kubernetes_fluent_client4.modelToGroupVersionKind)(model.name);
-    if (!matchedKind && !kind2) {
+  When = (model, kind3) => {
+    const matchedKind = (0, import_kubernetes_fluent_client5.modelToGroupVersionKind)(model.name);
+    if (!matchedKind && !kind3) {
       throw new Error(`Kind not specified for ${model.name}`);
     }
     const binding = {
       model,
       // If the kind is not specified, use the matched kind from the model
-      kind: kind2 || matchedKind,
+      kind: kind3 || matchedKind,
       event: "*" /* Any */,
       filters: {
         name: "",