wip

Signed-off-by: Attila Mészáros <a_meszaros@apple.com>

Author: csviri

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ResourceOperations.java

@@ -28,6 +28,7 @@
 import io.fabric8.kubernetes.client.dsl.base.PatchType;
 import io.javaoperatorsdk.operator.OperatorException;
 import io.javaoperatorsdk.operator.processing.event.ResourceID;
+import io.javaoperatorsdk.operator.processing.event.source.informer.InformerEventSource;
 import io.javaoperatorsdk.operator.processing.event.source.informer.ManagedInformerEventSource;
 
 import static io.javaoperatorsdk.operator.processing.KubernetesResourceUtils.getUID;
@@ -80,6 +81,40 @@ public <R extends HasMetadata> R serverSideApply(R resource) {
                         .build()));
   }
 
+  /**
+   * Updates the resource and caches the response if needed, thus making sure that next
+   * reconciliation will see to updated resource - or more recent one if additional update happened
+   * after this update; In addition to that it filters out the event from the update, so
+   * reconciliation is not triggered by own update.
+   *
+   * <p>You are free to control the optimistic locking by setting the resource version in resource
+   * metadata. In case of SSA we advise not to do updates with optimistic locking.
+   *
+   * @param resource fresh resource for server side apply
+   * @return updated resource
+   * @param informerEventSource InformerEventSource to use for resource caching and filtering
+   * @param <R> resource type
+   */
+  public <R extends HasMetadata> R serverSideApply(
+      R resource, InformerEventSource<R, P> informerEventSource) {
+    if (informerEventSource == null) {
+      return serverSideApply(resource);
+    }
+    return resourcePatch(
+        resource,
+        r ->
+            context
+                .getClient()
+                .resource(r)
+                .patch(
+                    new PatchContext.Builder()
+                        .withForce(true)
+                        .withFieldManager(context.getControllerConfiguration().fieldManager())
+                        .withPatchType(PatchType.SERVER_SIDE_APPLY)
+                        .build()),
+        informerEventSource);
+  }
+
   /**
    * Server-Side Apply the resource status subresource.
    *
@@ -189,6 +224,29 @@ public <R extends HasMetadata> R update(R resource) {
     return resourcePatch(resource, r -> context.getClient().resource(r).update());
   }
 
+  /**
+   * Updates the resource and caches the response if needed, thus making sure that next
+   * reconciliation will see to updated resource - or more recent one if additional update happened
+   * after this update; In addition to that it filters out the event from this update, so
+   * reconciliation is not triggered by own update.
+   *
+   * <p>You are free to control the optimistic locking by setting the resource version in resource
+   * metadata.
+   *
+   * @param resource resource to update
+   * @return updated resource
+   * @param informerEventSource InformerEventSource to use for resource caching and filtering
+   * @param <R> resource type
+   */
+  public <R extends HasMetadata> R update(
+      R resource, InformerEventSource<R, P> informerEventSource) {
+    if (informerEventSource == null) {
+      return update(resource);
+    }
+    return resourcePatch(
+        resource, r -> context.getClient().resource(r).update(), informerEventSource);
+  }
+
   /**
    * Creates the resource and caches the response if needed, thus making sure that next
    * reconciliation will see to updated resource - or more recent one if additional update happened
@@ -206,6 +264,29 @@ public <R extends HasMetadata> R create(R resource) {
     return resourcePatch(resource, r -> context.getClient().resource(r).create());
   }
 
+  /**
+   * Creates the resource and caches the response if needed, thus making sure that next
+   * reconciliation will see to updated resource - or more recent one if additional update happened
+   * after this update; In addition to that it filters out the event from this update, so
+   * reconciliation is not triggered by own update.
+   *
+   * <p>You are free to control the optimistic locking by setting the resource version in resource
+   * metadata.
+   *
+   * @param resource resource to update
+   * @return updated resource
+   * @param informerEventSource InformerEventSource to use for resource caching and filtering
+   * @param <R> resource type
+   */
+  public <R extends HasMetadata> R create(
+      R resource, InformerEventSource<R, P> informerEventSource) {
+    if (informerEventSource == null) {
+      return create(resource);
+    }
+    return resourcePatch(
+        resource, r -> context.getClient().resource(r).create(), informerEventSource);
+  }
+
   /**
    * Updates the resource status subresource.
    *

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/kubernetes/KubernetesDependentResource.java

@@ -92,8 +92,8 @@ public R create(R desired, P primary, Context<P> context) {
         ssa);
 
     return ssa
-        ? context.resourceOperations().serverSideApply(desired)
-        : context.resourceOperations().create(desired);
+        ? context.resourceOperations().serverSideApply(desired, eventSource().orElse(null))
+        : context.resourceOperations().create(desired, eventSource().orElse(null));
   }
 
   public R update(R actual, R desired, P primary, Context<P> context) {
@@ -113,10 +113,12 @@ public R update(R actual, R desired, P primary, Context<P> context) {
         ResourceID.fromResource(desired),
         ssa);
     if (ssa) {
-      updatedResource = context.resourceOperations().serverSideApply(desired);
+      updatedResource =
+          context.resourceOperations().serverSideApply(desired, eventSource().orElse(null));
     } else {
       var updatedActual = GenericResourceUpdater.updateResource(actual, desired, context);
-      updatedResource = context.resourceOperations().update(updatedActual);
+      updatedResource =
+          context.resourceOperations().update(updatedActual, eventSource().orElse(null));
     }
     log.debug(
         "Resource version after update: {}", updatedResource.getMetadata().getResourceVersion());