Dependent resources standalone mode

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/ReconcilerUtils.java

@@ -1,5 +1,7 @@
 package io.javaoperatorsdk.operator;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Locale;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
@@ -98,4 +100,19 @@ public static String getDefaultReconcilerName(String reconcilerClassName) {
     }
     return reconcilerClassName.toLowerCase(Locale.ROOT);
   }
+
+  public static boolean specsEqual(HasMetadata r1, HasMetadata r2) {
+    return getSpec(r1).equals(getSpec(r2));
+  }
+
+  // will be replaced with: https://github.com/fabric8io/kubernetes-client/issues/3816
+  public static Object getSpec(HasMetadata resource) {
+    try {
+      Method getSpecMethod = resource.getClass().getMethod("getSpec");
+      return getSpecMethod.invoke(resource);
+    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
 }

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

@@ -0,0 +1,31 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+
+public abstract class AbstractDependentResource<R, P extends HasMetadata>
+    implements DependentResource<R, P> {
+
+  @Override
+  public void reconcile(P primary, Context context) {
+    var actual = getResource(primary);
+    var desired = desired(primary, context);
+    if (actual.isEmpty()) {
+      create(desired, primary, context);
+    } else {
+      if (!match(actual.get(), desired, context)) {
+        update(actual.get(), desired, primary, context);
+      }
+    }
+  }
+
+  protected abstract R desired(P primary, Context context);
+
+  protected abstract boolean match(R actual, R target, Context context);
+
+  protected abstract R create(R target, P primary, Context context);
+
+  // the actual needed to copy/preserve new labels or annotations
+  protected abstract R update(R actual, R target, P primary, Context context);
+
+}

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

@@ -9,54 +9,18 @@
 import io.javaoperatorsdk.operator.processing.event.source.EventSource;
 
 public interface DependentResource<R, P extends HasMetadata> {
-  default EventSource initEventSource(EventSourceContext<P> context) {
-    throw new IllegalStateException("Must be implemented if not automatically provided by the SDK");
-  }
+
+  Optional<EventSource> eventSource(EventSourceContext<P> context);
 
   @SuppressWarnings("unchecked")
   default Class<R> resourceType() {
     return (Class<R>) Utils.getFirstTypeArgumentFromInterface(getClass());
   }
 
-  default void delete(R fetched, P primary, Context context) {}
-
-  /**
-   * Computes the desired state of the dependent based on the state provided by the specified
-   * primary resource.
-   * 
-   * The default implementation returns {@code empty} which corresponds to the case where the
-   * associated dependent should never be created by the associated reconciler or that the global
-   * state of the cluster doesn't allow for the resource to be created at this point.
-   * 
-   * @param primary the primary resource associated with the reconciliation process
-   * @param context the {@link Context} associated with the reconciliation process
-   * @return an instance of the dependent resource matching the desired state specified by the
-   *         primary resource or {@code empty} if the dependent shouldn't be created at this point
-   *         (or ever)
-   */
-  default Optional<R> desired(P primary, Context context) {
-    return Optional.empty();
-  }
+  void reconcile(P primary, Context context);
+
+  void delete(P primary, Context context);
+
+  Optional<R> getResource(P primaryResource);
 
-  /**
-   * Checks whether the actual resource as fetched from the cluster matches the desired state
-   * expressed by the specified primary resource.
-   * 
-   * The default implementation always return {@code true}, which corresponds to the behavior where
-   * the dependent never needs to be updated after it's been created.
-   * 
-   * Note that failure to properly implement this method will lead to infinite loops. In particular,
-   * for typical Kubernetes resource implementations, simply calling
-   * {@code desired(primary, context).equals(actual)} is not enough because metadata will usually be
-   * different.
-   * 
-   * @param actual the current state of the resource as fetched from the cluster
-   * @param primary the primary resource associated with the reconciliation request
-   * @param context the {@link Context} associated with the reconciliation request
-   * @return {@code true} if the actual state of the resource matches the desired state expressed by
-   *         the specified primary resource, {@code false} otherwise
-   */
-  default boolean match(R actual, P primary, Context context) {
-    return true;
-  }
 }

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

@@ -0,0 +1,10 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+
+@FunctionalInterface
+public interface DesiredSupplier<R, P> {
+
+  R getDesired(P primary, Context context);
+
+}

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

@@ -0,0 +1,150 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import java.util.Optional;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.fabric8.kubernetes.client.KubernetesClient;
+import io.javaoperatorsdk.operator.ReconcilerUtils;
+import io.javaoperatorsdk.operator.api.config.informer.InformerConfiguration;
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+import io.javaoperatorsdk.operator.api.reconciler.EventSourceContext;
+import io.javaoperatorsdk.operator.processing.event.ResourceID;
+import io.javaoperatorsdk.operator.processing.event.source.AssociatedSecondaryResourceIdentifier;
+import io.javaoperatorsdk.operator.processing.event.source.EventSource;
+import io.javaoperatorsdk.operator.processing.event.source.PrimaryResourcesRetriever;
+import io.javaoperatorsdk.operator.processing.event.source.informer.InformerEventSource;
+import io.javaoperatorsdk.operator.processing.event.source.informer.Mappers;
+
+public abstract class KubernetesDependentResource<R extends HasMetadata, P extends HasMetadata>
+    extends AbstractDependentResource<R, P> {
+
+  private static final Logger log = LoggerFactory.getLogger(KubernetesDependentResource.class);
+
+  protected KubernetesClient client;
+  private boolean explicitDelete = false;
+  private boolean owned = true;
+  private InformerEventSource<R, P> informerEventSource;
+
+  public KubernetesDependentResource() {
+    this(null);
+  }
+
+  public KubernetesDependentResource(KubernetesClient client) {
+    this.client = client;
+  }
+
+  protected void beforeCreateOrUpdate(R desired, P primary) {
+    if (owned) {
+      desired.addOwnerReference(primary);
+    }
+  }
+
+  @Override
+  protected boolean match(R actual, R target, Context context) {
+    return ReconcilerUtils.specsEqual(actual, target);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  protected R create(R target, P primary, Context context) {
+    log.debug("Creating target resource with type: " +
+        "{}, with id: {}", target.getClass(), ResourceID.fromResource(target));
+    beforeCreateOrUpdate(target, primary);
+    Class<R> targetClass = (Class<R>) target.getClass();
+    return client.resources(targetClass).inNamespace(target.getMetadata().getNamespace())
+        .create(target);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  protected R update(R actual, R target, P primary, Context context) {
+    log.debug("Updating target resource with type: {}, with id: {}", target.getClass(),
+        ResourceID.fromResource(target));
+    beforeCreateOrUpdate(target, primary);
+    Class<R> targetClass = (Class<R>) target.getClass();
+    return client.resources(targetClass).inNamespace(target.getMetadata().getNamespace())
+        .replace(target);
+  }
+
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  @Override
+  public Optional<EventSource> eventSource(EventSourceContext<P> context) {
+    if (informerEventSource != null) {
+      return Optional.of(informerEventSource);
+    }
+    var informerConfig = initInformerConfiguration(context);
+    informerEventSource = new InformerEventSource(informerConfig, context);
+    return Optional.of(informerEventSource);
+  }
+
+  @SuppressWarnings("unchecked")
+  private InformerConfiguration<R, P> initInformerConfiguration(EventSourceContext<P> context) {
+    PrimaryResourcesRetriever<R> associatedPrimaries =
+        (this instanceof PrimaryResourcesRetriever) ? (PrimaryResourcesRetriever<R>) this
+            : getDefaultPrimaryResourcesRetriever();
+
+    AssociatedSecondaryResourceIdentifier<P> associatedSecondary =
+        (this instanceof AssociatedSecondaryResourceIdentifier)
+            ? (AssociatedSecondaryResourceIdentifier<P>) this
+            : getDefaultAssociatedSecondaryResourceIdentifier();
+
+    return InformerConfiguration.from(context, resourceType())
+        .withPrimaryResourcesRetriever(associatedPrimaries)
+        .withAssociatedSecondaryResourceIdentifier(associatedSecondary)
+        .build();
+  }
+
+  protected AssociatedSecondaryResourceIdentifier<P> getDefaultAssociatedSecondaryResourceIdentifier() {
+    return ResourceID::fromResource;
+  }
+
+  protected PrimaryResourcesRetriever<R> getDefaultPrimaryResourcesRetriever() {
+    return Mappers.fromOwnerReference();
+  }
+
+  public KubernetesDependentResource<R, P> setInformerEventSource(
+      InformerEventSource<R, P> informerEventSource) {
+    this.informerEventSource = informerEventSource;
+    return this;
+  }
+
+  @Override
+  public void delete(P primary, Context context) {
+    if (explicitDelete) {
+      var resource = getResource(primary);
+      resource.ifPresent(r -> client.resource(r).delete());
+    }
+  }
+
+  @Override
+  public Optional<R> getResource(P primaryResource) {
+    return informerEventSource.getAssociated(primaryResource);
+  }
+
+  public KubernetesDependentResource<R, P> setClient(KubernetesClient client) {
+    this.client = client;
+    return this;
+  }
+
+
+  public KubernetesDependentResource<R, P> setExplicitDelete(boolean explicitDelete) {
+    this.explicitDelete = explicitDelete;
+    return this;
+  }
+
+  public boolean isExplicitDelete() {
+    return explicitDelete;
+  }
+
+  public boolean isOwned() {
+    return owned;
+  }
+
+  public KubernetesDependentResource<R, P> setOwned(boolean owned) {
+    this.owned = owned;
+    return this;
+  }
+}

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

@@ -0,0 +1,63 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.fabric8.kubernetes.client.KubernetesClient;
+import io.javaoperatorsdk.operator.api.reconciler.Context;
+import io.javaoperatorsdk.operator.processing.event.ResourceID;
+import io.javaoperatorsdk.operator.processing.event.source.AssociatedSecondaryResourceIdentifier;
+import io.javaoperatorsdk.operator.processing.event.source.PrimaryResourcesRetriever;
+import io.javaoperatorsdk.operator.processing.event.source.informer.Mappers;
+
+// todo shorter name
+public class StandaloneKubernetesDependentResource<R extends HasMetadata, P extends HasMetadata>
+    extends KubernetesDependentResource<R, P> {
+
+  private final DesiredSupplier<R, P> desiredSupplier;
+  private final Class<R> resourceType;
+  private AssociatedSecondaryResourceIdentifier<P> associatedSecondaryResourceIdentifier =
+      ResourceID::fromResource;
+  private PrimaryResourcesRetriever<R> primaryResourcesRetriever = Mappers.fromOwnerReference();
+
+  public StandaloneKubernetesDependentResource(
+      Class<R> resourceType, DesiredSupplier<R, P> desiredSupplier) {
+    this(null, resourceType, desiredSupplier);
+  }
+
+  public StandaloneKubernetesDependentResource(
+      KubernetesClient client, Class<R> resourceType, DesiredSupplier<R, P> desiredSupplier) {
+    super(client);
+    this.desiredSupplier = desiredSupplier;
+    this.resourceType = resourceType;
+  }
+
+  @Override
+  protected R desired(P primary, Context context) {
+    return desiredSupplier.getDesired(primary, context);
+  }
+
+  public Class<R> resourceType() {
+    return resourceType;
+  }
+
+  public StandaloneKubernetesDependentResource<R, P> setAssociatedSecondaryResourceIdentifier(
+      AssociatedSecondaryResourceIdentifier<P> associatedSecondaryResourceIdentifier) {
+    this.associatedSecondaryResourceIdentifier = associatedSecondaryResourceIdentifier;
+    return this;
+  }
+
+  public StandaloneKubernetesDependentResource<R, P> setPrimaryResourcesRetriever(
+      PrimaryResourcesRetriever<R> primaryResourcesRetriever) {
+    this.primaryResourcesRetriever = primaryResourcesRetriever;
+    return this;
+  }
+
+  @Override
+  protected AssociatedSecondaryResourceIdentifier<P> getDefaultAssociatedSecondaryResourceIdentifier() {
+    return this.associatedSecondaryResourceIdentifier;
+  }
+
+  @Override
+  protected PrimaryResourcesRetriever<R> getDefaultPrimaryResourcesRetriever() {
+    return this.primaryResourcesRetriever;
+  }
+}