Dependent resources standalone mode

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

@@ -0,0 +1,33 @@
+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, context);
+    } else {
+      if (!match(actual.get(), desired, context)) {
+        update(actual.get(), desired, context);
+      }
+    }
+  }
+
+  protected abstract R desired(P primary, Context context);
+
+  protected boolean match(R actual, R target, Context context) {
+    return actual.equals(target);
+  }
+
+  protected abstract R create(R target, Context context);
+
+  // the actual needed to copy/preserve new labels or annotations
+  protected abstract R update(R actual, R target, 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/KubernetesDependentResource.java

@@ -0,0 +1,98 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import java.util.Optional;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.fabric8.kubernetes.client.KubernetesClient;
+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 KubernetesClient client;
+  private boolean manageDelete;
+  private InformerEventSource<R, P> informerEventSource;
+
+  public KubernetesDependentResource() {
+    this(null, false);
+  }
+
+  public KubernetesDependentResource(KubernetesClient client) {
+    this(client, false);
+  }
+
+  public KubernetesDependentResource(KubernetesClient client, boolean manageDelete) {
+    this.client = client;
+    this.manageDelete = manageDelete;
+  }
+
+  @Override
+  protected R create(R target, Context context) {
+    return client.resource(target).createOrReplace();
+  }
+
+  @Override
+  protected R update(R actual, R target, Context context) {
+    // todo map annotation and labels ?
+    return client.resource(target).createOrReplace();
+  }
+
+  @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);
+  }
+
+  private InformerConfiguration<R, P> initInformerConfiguration(EventSourceContext<P> context) {
+    PrimaryResourcesRetriever<R> associatedPrimaries =
+        (this instanceof PrimaryResourcesRetriever) ? (PrimaryResourcesRetriever<R>) this
+            : Mappers.fromOwnerReference();
+
+    AssociatedSecondaryResourceIdentifier<R> associatedSecondary =
+        (this instanceof AssociatedSecondaryResourceIdentifier)
+            ? (AssociatedSecondaryResourceIdentifier<R>) this
+            : (r) -> ResourceID.fromResource(r);
+
+    return InformerConfiguration.from(context, resourceType())
+        .withPrimaryResourcesRetriever(associatedPrimaries)
+        .withAssociatedSecondaryResourceIdentifier(
+            (AssociatedSecondaryResourceIdentifier<P>) associatedSecondary)
+        .build();
+  }
+
+  public KubernetesDependentResource<R, P> withInformerEventSource(
+      InformerEventSource<R, P> informerEventSource) {
+    this.informerEventSource = informerEventSource;
+    return this;
+  }
+
+  @Override
+  public void delete(P primary, Context context) {
+    if (manageDelete) {
+      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;
+  }
+}

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

@@ -0,0 +1,19 @@
+package io.javaoperatorsdk.operator.api.reconciler.dependent;
+
+import java.util.Optional;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.EventSourceContext;
+import io.javaoperatorsdk.operator.processing.event.source.EventSource;
+
+// todo resource: resource which we don't manage just aware of, and needs it for input
+//
+public interface ObservedResource<R, P extends HasMetadata> {
+
+  default Optional<EventSource> initEventSource(EventSourceContext<P> context) {
+    return Optional.empty();
+  }
+
+  Optional<R> getResource();
+
+}

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

@@ -8,28 +8,22 @@
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.config.dependent.DependentResourceConfiguration;
 import io.javaoperatorsdk.operator.api.reconciler.Context;
-import io.javaoperatorsdk.operator.api.reconciler.DeleteControl;
 import io.javaoperatorsdk.operator.api.reconciler.EventSourceContext;
 import io.javaoperatorsdk.operator.api.reconciler.Ignore;
-import io.javaoperatorsdk.operator.api.reconciler.Reconciler;
-import io.javaoperatorsdk.operator.api.reconciler.UpdateControl;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
-import io.javaoperatorsdk.operator.api.reconciler.dependent.Persister;
 import io.javaoperatorsdk.operator.processing.event.source.EventSource;
 
 @Ignore
 public class DependentResourceController<R, P extends HasMetadata, C extends DependentResourceConfiguration<R, P>>
-    implements DependentResource<R, P>, Persister<R, P>, Reconciler<P> {
+    implements DependentResource<R, P> {
 
   private static final Logger log = LoggerFactory.getLogger(DependentResourceController.class);
 
-  private final Persister<R, P> persister;
-  private final DependentResource<R, P> delegate;
+  protected final DependentResource<R, P> delegate;
   private final C configuration;
 
   public DependentResourceController(DependentResource<R, P> delegate, C configuration) {
     this.delegate = delegate;
-    persister = initPersister(delegate);
     this.configuration = configuration;
   }
 
@@ -39,96 +33,30 @@ public Class<R> resourceType() {
   }
 
   @Override
-  public boolean match(R actual, P primary, Context context) {
-    return delegate.match(actual, primary, context);
+  public void delete(P primary, Context context) {
+    delegate.delete(primary, context);
   }
 
   @Override
-  public Optional<R> desired(P primary, Context context) {
-    return delegate.desired(primary, context);
+  public Optional<R> getResource(P primaryResource) {
+    return delegate.getResource(primaryResource);
   }
 
-  @Override
-  public void delete(R fetched, P primary, Context context) {
-    delegate.delete(fetched, primary, context);
-  }
-
-  @SuppressWarnings("unchecked")
-  protected Persister<R, P> initPersister(DependentResource<R, P> delegate) {
-    if (delegate instanceof Persister) {
-      return (Persister<R, P>) delegate;
-    } else {
-      throw new IllegalArgumentException(
-          "DependentResource '" + delegate.getClass().getName() + "' must implement Persister");
-    }
-  }
-
-  public String descriptionFor(R resource) {
-    return resource.toString();
-  }
-
-  public Class<R> getResourceType() {
-    return delegate.resourceType();
-  }
-
-  @Override
-  public EventSource initEventSource(EventSourceContext<P> context) {
-    return delegate.initEventSource(context);
-  }
 
   @Override
-  public void createOrReplace(R dependentResource, Context context) {
-    persister.createOrReplace(dependentResource, context);
+  public Optional<EventSource> eventSource(EventSourceContext<P> context) {
+    return delegate.eventSource(context);
   }
 
-  @Override
-  public R getFor(P primary, Context context) {
-    return persister.getFor(primary, context);
-  }
 
   public C getConfiguration() {
     return configuration;
   }
 
   @Override
-  public UpdateControl<P> reconcile(P resource, Context context) {
-    var actual = getFor(resource, context);
-    if (actual == null || !match(actual, resource, context)) {
-      final var desired = desired(resource, context);
-      desired.ifPresent(d -> createOrReplaceDependent(resource, d, context));
-    }
-    return UpdateControl.noUpdate();
-  }
-
-  @Override
-  public DeleteControl cleanup(P primary, Context context) {
-    var dependent = getFor(primary, context);
-    if (dependent != null) {
-      delete(dependent, primary, context);
-      logOperationInfo(primary, dependent, "Deleting");
-    } else {
-      log.info("Ignoring already deleted {} for '{}' {}",
-          getResourceType().getName(),
-          primary.getMetadata().getName(),
-          primary.getKind());
-    }
-    return Reconciler.super.cleanup(primary, context);
+  public void reconcile(P resource, Context context) {
+    delegate.reconcile(resource, context);
   }
 
-  protected void createOrReplaceDependent(P primary, R dependent, Context context) {
-    logOperationInfo(primary, dependent, "Reconciling");
 
-    // commit the changes
-    // todo: add metrics timing for dependent resource
-    createOrReplace(dependent, context);
-  }
-
-  private void logOperationInfo(P resource, R dependentResource, String operationDescription) {
-    if (log.isInfoEnabled()) {
-      log.info("{} {} for '{}' {}", operationDescription,
-          descriptionFor(dependentResource),
-          resource.getMetadata().getName(),
-          resource.getKind());
-    }
-  }
 }