fix: grammar issue (#3083)

Signed-off-by: Chris Laprun <metacosm@gmail.com>

Author: metacosm

docs/content/en/blog/releases/v5-2-release.md

@@ -44,7 +44,7 @@ See the [migration guide](/docs/migration/v5-2-migration) for detailed migration
 ### Trigger Reconciliation on All Events
 
 Version 5.2 introduces a new execution mode that provides finer control over when reconciliation occurs. By setting
-[`triggerReconcilerOnAllEvent`](https://github.com/operator-framework/java-operator-sdk/blob/main/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ControllerConfiguration.java)
+[`triggerReconcilerOnAllEvents`](https://github.com/operator-framework/java-operator-sdk/blob/main/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ControllerConfiguration.java)
 to `true`, your `reconcile` method will be called for **every** event, including `Delete` events.
 
 This is particularly useful when:
@@ -61,7 +61,7 @@ When enabled:
 Example:
 
 ```java
-@ControllerConfiguration(triggerReconcilerOnAllEvent = true)
+@ControllerConfiguration(triggerReconcilerOnAllEvents = true)
 public class MyReconciler implements Reconciler<MyResource> {
 
     @Override

docs/content/en/docs/documentation/reconciler.md

@@ -239,7 +239,7 @@ However, there are cases when controllers do not strictly follow those patterns,
   and you don't want to use finalizers. For those cases, you typically want to clean up your caches when the primary
   resource is deleted.
 
-For such use cases you can set [`triggerReconcilerOnAllEvent`](https://github.com/operator-framework/java-operator-sdk/blob/main/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ControllerConfiguration.java#L81)
+For such use cases you can set [`triggerReconcilerOnAllEvents`](https://github.com/operator-framework/java-operator-sdk/blob/main/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ControllerConfiguration.java#L107)
 to `true`, as a result, the `reconcile` method will be triggered on ALL events (so also `Delete` events), making it
 possible to support the above use cases.
 

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/BaseConfigurationService.java

@@ -319,8 +319,8 @@ private <P extends HasMetadata> ResolvedControllerConfiguration<P> controllerCon
     final var dependentFieldManager =
         fieldManager.equals(CONTROLLER_NAME_AS_FIELD_MANAGER) ? name : fieldManager;
 
-    var triggerReconcilerOnAllEvent =
-        annotation != null && annotation.triggerReconcilerOnAllEvent();
+    var triggerReconcilerOnAllEvents =
+        annotation != null && annotation.triggerReconcilerOnAllEvents();
 
     InformerConfiguration<P> informerConfig =
         InformerConfiguration.builder(resourceClass)
@@ -342,7 +342,7 @@ private <P extends HasMetadata> ResolvedControllerConfiguration<P> controllerCon
         dependentFieldManager,
         this,
         informerConfig,
-        triggerReconcilerOnAllEvent);
+        triggerReconcilerOnAllEvents);
   }
 
   /**

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ControllerConfiguration.java

@@ -108,7 +108,15 @@ default String fieldManager() {
 
   <C> C getConfigurationFor(DependentResourceSpec<?, P, C> spec);
 
+  /**
+   * @deprecated use {@link #triggerReconcilerOnAllEvents()} instead
+   */
+  @Deprecated(forRemoval = true)
   default boolean triggerReconcilerOnAllEvent() {
+    return triggerReconcilerOnAllEvents();
+  }
+
+  default boolean triggerReconcilerOnAllEvents() {
     return false;
   }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ControllerConfigurationOverrider.java

@@ -45,7 +45,7 @@ public class ControllerConfigurationOverrider<R extends HasMetadata> {
   private Duration reconciliationMaxInterval;
   private Map<DependentResourceSpec, Object> configurations;
   private final InformerConfiguration<R>.Builder config;
-  private boolean triggerReconcilerOnAllEvent;
+  private boolean triggerReconcilerOnAllEvents;
 
   private ControllerConfigurationOverrider(ControllerConfiguration<R> original) {
     this.finalizer = original.getFinalizerName();
@@ -58,7 +58,7 @@ private ControllerConfigurationOverrider(ControllerConfiguration<R> original) {
     this.rateLimiter = original.getRateLimiter();
     this.name = original.getName();
     this.fieldManager = original.fieldManager();
-    this.triggerReconcilerOnAllEvent = original.triggerReconcilerOnAllEvent();
+    this.triggerReconcilerOnAllEvents = original.triggerReconcilerOnAllEvents();
   }
 
   public ControllerConfigurationOverrider<R> withFinalizer(String finalizer) {
@@ -171,9 +171,18 @@ public ControllerConfigurationOverrider<R> withFieldManager(String dependentFiel
     return this;
   }
 
+  /**
+   * @deprecated use {@link #withTriggerReconcilerOnAllEvents(boolean)} instead
+   */
+  @Deprecated(forRemoval = true)
   public ControllerConfigurationOverrider<R> withTriggerReconcilerOnAllEvent(
-      boolean triggerReconcilerOnAllEvent) {
-    this.triggerReconcilerOnAllEvent = triggerReconcilerOnAllEvent;
+      boolean triggerReconcilerOnAllEvents) {
+    return withTriggerReconcilerOnAllEvents(triggerReconcilerOnAllEvents);
+  }
+
+  public ControllerConfigurationOverrider<R> withTriggerReconcilerOnAllEvents(
+      boolean triggerReconcilerOnAllEvents) {
+    this.triggerReconcilerOnAllEvents = triggerReconcilerOnAllEvents;
     return this;
   }
 
@@ -221,7 +230,7 @@ public ControllerConfiguration<R> build() {
         fieldManager,
         original.getConfigurationService(),
         config.buildForController(),
-        triggerReconcilerOnAllEvent,
+        triggerReconcilerOnAllEvents,
         original.getWorkflowSpec().orElse(null));
   }
 

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/ResolvedControllerConfiguration.java

@@ -44,7 +44,7 @@ public class ResolvedControllerConfiguration<P extends HasMetadata>
   private final Map<DependentResourceSpec, Object> configurations;
   private final ConfigurationService configurationService;
   private final String fieldManager;
-  private final boolean triggerReconcilerOnAllEvent;
+  private final boolean triggerReconcilerOnAllEvents;
   private WorkflowSpec workflowSpec;
 
   public ResolvedControllerConfiguration(ControllerConfiguration<P> other) {
@@ -60,7 +60,7 @@ public ResolvedControllerConfiguration(ControllerConfiguration<P> other) {
         other.fieldManager(),
         other.getConfigurationService(),
         other.getInformerConfig(),
-        other.triggerReconcilerOnAllEvent(),
+        other.triggerReconcilerOnAllEvents(),
         other.getWorkflowSpec().orElse(null));
   }
 
@@ -76,7 +76,7 @@ public ResolvedControllerConfiguration(
       String fieldManager,
       ConfigurationService configurationService,
       InformerConfiguration<P> informerConfig,
-      boolean triggerReconcilerOnAllEvent,
+      boolean triggerReconcilerOnAllEvents,
       WorkflowSpec workflowSpec) {
     this(
         name,
@@ -90,7 +90,7 @@ public ResolvedControllerConfiguration(
         fieldManager,
         configurationService,
         informerConfig,
-        triggerReconcilerOnAllEvent);
+        triggerReconcilerOnAllEvents);
     setWorkflowSpec(workflowSpec);
   }
 
@@ -106,7 +106,7 @@ protected ResolvedControllerConfiguration(
       String fieldManager,
       ConfigurationService configurationService,
       InformerConfiguration<P> informerConfig,
-      boolean triggerReconcilerOnAllEvent) {
+      boolean triggerReconcilerOnAllEvents) {
     this.informerConfig = informerConfig;
     this.configurationService = configurationService;
     this.name = ControllerConfiguration.ensureValidName(name, associatedReconcilerClassName);
@@ -119,7 +119,7 @@ protected ResolvedControllerConfiguration(
     this.finalizer =
         ControllerConfiguration.ensureValidFinalizerName(finalizer, getResourceTypeName());
     this.fieldManager = fieldManager;
-    this.triggerReconcilerOnAllEvent = triggerReconcilerOnAllEvent;
+    this.triggerReconcilerOnAllEvents = triggerReconcilerOnAllEvents;
   }
 
   protected ResolvedControllerConfiguration(
@@ -231,7 +231,7 @@ public String fieldManager() {
   }
 
   @Override
-  public boolean triggerReconcilerOnAllEvent() {
-    return triggerReconcilerOnAllEvent;
+  public boolean triggerReconcilerOnAllEvents() {
+    return triggerReconcilerOnAllEvents;
   }
 }

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

@@ -91,7 +91,7 @@ default <R> Stream<R> getSecondaryResourcesAsStream(Class<R> expectedType) {
   /**
    * To check if the primary resource is already deleted. This value can be true only if you turn on
    * {@link
-   * io.javaoperatorsdk.operator.api.reconciler.ControllerConfiguration#triggerReconcilerOnAllEvent()}
+   * io.javaoperatorsdk.operator.api.reconciler.ControllerConfiguration#triggerReconcilerOnAllEvents()}
    *
    * @return true Delete event received for primary resource
    * @since 5.2.0

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

@@ -93,10 +93,16 @@ MaxReconciliationInterval maxReconciliationInterval() default
    */
   String fieldManager() default CONTROLLER_NAME_AS_FIELD_MANAGER;
 
+  /**
+   * @deprecated use {@link #triggerReconcilerOnAllEvents()} instead
+   */
+  @Deprecated(forRemoval = true)
+  boolean triggerReconcilerOnAllEvent() default false;
+
   /**
    * By settings to true, reconcile method will be triggered on every event, thus even for Delete
    * event. You cannot use {@link Cleaner} or managed dependent resources in that case. See
    * documentation for further details.
    */
-  boolean triggerReconcilerOnAllEvent() default false;
+  boolean triggerReconcilerOnAllEvents() default false;
 }

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

@@ -77,10 +77,10 @@ public class Controller<P extends HasMetadata>
   private static final String STATUS = "status";
   private static final String BOTH = "both";
   public static final String CLEANER_NOT_SUPPORTED_ON_ALL_EVENT_ERROR_MESSAGE =
-      "Cleaner is not supported when triggerReconcilerOnAllEvent enabled.";
+      "Cleaner is not supported when triggerReconcilerOnAllEvents enabled.";
   public static final String
       MANAGED_WORKFLOWS_NOT_SUPPORTED_TRIGGER_RECONCILER_ON_ALL_EVENT_ERROR_MESSAGE =
-          "Managed workflows are not supported when triggerReconcilerOnAllEvent enabled.";
+          "Managed workflows are not supported when triggerReconcilerOnAllEvents enabled.";
 
   private final Reconciler<P> reconciler;
   private final ControllerConfiguration<P> configuration;
@@ -117,7 +117,7 @@ public Controller(
     explicitWorkflowInvocation =
         configuration.getWorkflowSpec().map(WorkflowSpec::isExplicitInvocation).orElse(false);
 
-    if (configuration.triggerReconcilerOnAllEvent()) {
+    if (configuration.triggerReconcilerOnAllEvents()) {
       if (isCleaner) {
         throw new OperatorException(CLEANER_NOT_SUPPORTED_ON_ALL_EVENT_ERROR_MESSAGE);
       }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/EventProcessor.java

@@ -146,7 +146,7 @@ public synchronized void handleEvent(Event event) {
   }
 
   private void handleMarkedEventForResource(ResourceState state) {
-    if (state.deleteEventPresent() && !triggerOnAllEvent()) {
+    if (state.deleteEventPresent() && !triggerOnAllEvents()) {
       cleanupForDeletedEvent(state.getId());
     } else if (!state.processedMarkForDeletionPresent()) {
       submitReconciliationExecution(state);
@@ -181,7 +181,7 @@ private void submitReconciliationExecution(ResourceState state) {
                 state.getRetry(),
                 state.deleteEventPresent(),
                 state.isDeleteFinalStateUnknown());
-        state.unMarkEventReceived(triggerOnAllEvent());
+        state.unMarkEventReceived(triggerOnAllEvents());
         metrics.reconcileCustomResource(latest, state.getRetry(), metricsMetadata);
         log.debug("Executing events for custom resource. Scope: {}", executionScope);
         executor.execute(new ReconcilerExecutor(resourceID, executionScope));
@@ -208,7 +208,7 @@ private void submitReconciliationExecution(ResourceState state) {
 
   @SuppressWarnings("unchecked")
   private P getResourceFromState(ResourceState state) {
-    if (triggerOnAllEvent()) {
+    if (triggerOnAllEvents()) {
       log.debug("Getting resource from state for {}", state.getId());
       return (P) state.getLastKnownResource();
     } else {
@@ -239,10 +239,10 @@ private void handleEventMarking(Event event, ResourceState state) {
         // removed, but also the informers websocket is disconnected and later reconnected. So
         // meanwhile the resource could be deleted and recreated. In this case we just mark a new
         // event as below.
-        state.markEventReceived(triggerOnAllEvent());
+        state.markEventReceived(triggerOnAllEvents());
       }
     } else if (!state.deleteEventPresent() && !state.processedMarkForDeletionPresent()) {
-      state.markEventReceived(triggerOnAllEvent());
+      state.markEventReceived(triggerOnAllEvents());
     } else if (isTriggerOnAllEventAndDeleteEventPresent(state)) {
       state.markAdditionalEventAfterDeleteEvent();
     } else if (log.isDebugEnabled()) {
@@ -286,15 +286,15 @@ synchronized void eventProcessingFinished(
     // Either way we don't want to retry.
     if (isRetryConfigured()
         && postExecutionControl.exceptionDuringExecution()
-        && (!state.deleteEventPresent() || triggerOnAllEvent())) {
+        && (!state.deleteEventPresent() || triggerOnAllEvents())) {
       handleRetryOnException(
           executionScope, postExecutionControl.getRuntimeException().orElseThrow());
       return;
     }
     cleanupOnSuccessfulExecution(executionScope);
     metrics.finishedReconciliation(executionScope.getResource(), metricsMetadata);
-    if ((triggerOnAllEvent() && executionScope.isDeleteEvent())
-        || (!triggerOnAllEvent() && state.deleteEventPresent())) {
+    if ((triggerOnAllEvents() && executionScope.isDeleteEvent())
+        || (!triggerOnAllEvents() && state.deleteEventPresent())) {
       cleanupForDeletedEvent(executionScope.getResourceID());
     } else if (postExecutionControl.isFinalizerRemoved()) {
       state.markProcessedMarkForDeletion();
@@ -310,7 +310,7 @@ synchronized void eventProcessingFinished(
   }
 
   private boolean isTriggerOnAllEventAndDeleteEventPresent(ResourceState state) {
-    return triggerOnAllEvent() && state.deleteEventPresent();
+    return triggerOnAllEvents() && state.deleteEventPresent();
   }
 
   /**
@@ -370,8 +370,8 @@ private void handleRetryOnException(ExecutionScope<P> executionScope, Exception
     var resourceID = state.getId();
     boolean eventPresent =
         state.eventPresent()
-            || (triggerOnAllEvent() && state.isAdditionalEventPresentAfterDeleteEvent());
-    state.markEventReceived(triggerOnAllEvent());
+            || (triggerOnAllEvents() && state.isAdditionalEventPresentAfterDeleteEvent());
+    state.markEventReceived(triggerOnAllEvents());
 
     retryAwareErrorLogging(state.getRetry(), eventPresent, exception, executionScope);
     if (eventPresent) {
@@ -517,7 +517,7 @@ public void run() {
         // we try to get the most up-to-date resource from cache
         var actualResource = cache.get(resourceID);
         if (actualResource.isEmpty()) {
-          if (triggerOnAllEvent()) {
+          if (triggerOnAllEvents()) {
             log.debug(
                 "Resource not found in the cache, checking for delete event resource: {}",
                 resourceID);
@@ -578,7 +578,7 @@ public synchronized boolean isRunning() {
   }
 
   // shortening
-  private boolean triggerOnAllEvent() {
-    return controllerConfiguration.triggerReconcilerOnAllEvent();
+  private boolean triggerOnAllEvents() {
+    return controllerConfiguration.triggerReconcilerOnAllEvents();
   }
 }