Cherry-pick changes from branch 'owls-108056' into 'release/4.0'

Author: rjeberhard

operator/src/main/java/oracle/kubernetes/operator/DomainStatusUpdater.java

@@ -200,9 +200,10 @@ private boolean wasNotRolling() {
   /**
    * Creates an asynchronous step to initialize the domain status, if needed, to indicate that the operator has
    * seen the domain and is now working on it.
+   * @param hasEventData tue if the make right operation is associated with an event data
    */
-  public static Step createStatusInitializationStep() {
-    return new StatusInitializationStep();
+  public static Step createStatusInitializationStep(boolean hasEventData) {
+    return new StatusInitializationStep(hasEventData);
   }
 
   /**
@@ -592,12 +593,23 @@ void addDomainEvent(DomainCondition condition) {
   }
 
   public static class StatusInitializationStep extends DomainStatusUpdaterStep {
+    private boolean hasEventData;
+
+    StatusInitializationStep(boolean hasEventData) {
+      super();
+      this.hasEventData = hasEventData;
+    }
 
     @Override
     void modifyStatus(DomainStatus status) {
       if (status.getConditions().isEmpty()) {
-        status.addCondition(new DomainCondition(COMPLETED).withStatus(false));
-        status.addCondition(new DomainCondition(AVAILABLE).withStatus(false));
+        if (hasEventData) {
+          status.addCondition(new DomainCondition(COMPLETED).withStatus(false));
+          status.addCondition(new DomainCondition(AVAILABLE).withStatus(false));
+        }
+      } else {
+        status.markFailuresForRemoval(KUBERNETES);
+        status.removeMarkedFailures();
       }
     }
   }
@@ -765,11 +777,8 @@ class Conditions {
         public Conditions(DomainStatus status) {
           this.status = status != null ? status : new DomainStatus();
           this.clusterChecks = createClusterChecks();
-          boolean isCompleted = isProcessingCompleted();
+          boolean isCompleted = isProcessingCompleted() && !this.status.hasConditionWithType(FAILED);
           conditionList.add(new DomainCondition(COMPLETED).withStatus(isCompleted));
-          if (isCompleted && this.status.hasConditionWithType(FAILED)) {
-            this.status.removeConditionsWithType(FAILED);
-          }
           conditionList.add(createAvailableCondition());
           if (allIntendedServersReady()) {
             this.status.removeConditionsWithType(ROLLING);

operator/src/main/java/oracle/kubernetes/operator/makeright/MakeRightDomainOperationImpl.java

@@ -211,9 +211,7 @@ public Step createSteps() {
 
     result.add(Optional.ofNullable(eventData).map(EventHelper::createEventStep).orElse(null));
     result.add(new DomainProcessorImpl.PopulatePacketServerMapsStep());
-    if (hasEventData()) {
-      result.add(createStatusInitializationStep());
-    }
+    result.add(createStatusInitializationStep(hasEventData()));
     if (deleting || domainHasDeletionTimestamp()) {
       result.add(new StartPlanStep(liveInfo, createDomainDownPlan()));
     } else {

operator/src/test/java/oracle/kubernetes/operator/DomainProcessorTest.java

@@ -169,6 +169,9 @@
 import static oracle.kubernetes.weblogic.domain.model.DomainConditionType.COMPLETED;
 import static oracle.kubernetes.weblogic.domain.model.DomainConditionType.FAILED;
 import static oracle.kubernetes.weblogic.domain.model.DomainFailureReason.ABORTED;
+import static oracle.kubernetes.weblogic.domain.model.DomainFailureReason.DOMAIN_INVALID;
+import static oracle.kubernetes.weblogic.domain.model.DomainFailureReason.KUBERNETES;
+import static oracle.kubernetes.weblogic.domain.model.DomainStatusNoConditionMatcher.hasNoCondition;
 import static org.hamcrest.Matchers.allOf;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.empty;
@@ -685,6 +688,22 @@ void afterServersUpdated_updateDomainStatus() {
     assertThat(testSupport.getResourceWithName(DOMAIN, UID), hasCondition(COMPLETED).withStatus("True"));
   }
 
+  @Test
+  void afterServersUpdatedWhenFailedConditionExists_dontUpdateDomainStatus() {
+    domainConfigurator.configureCluster(newInfo, CLUSTER).withReplicas(MIN_REPLICAS);
+    newInfo.getReferencedClusters().forEach(testSupport::defineResources);
+    processor.createMakeRightOperation(newInfo).execute();
+    newInfo.setWebLogicCredentialsSecret(createCredentialsSecret());
+    newDomain.getOrCreateStatus().addCondition(new DomainCondition(FAILED).withReason(KUBERNETES).withStatus(true));
+    makePodsReady();
+    makePodsHealthy();
+
+    triggerStatusUpdate();
+
+    assertThat(((DomainResource)testSupport.getResourceWithName(DOMAIN, UID)).getStatus(),
+        hasNoCondition(COMPLETED).withStatus("True"));
+  }
+
   @Test
   void afterChangeToNever_statusUpdateRetainsStateGoal() {
     domainConfigurator.configureCluster(newInfo, CLUSTER).withReplicas(MIN_REPLICAS);
@@ -1530,6 +1549,24 @@ void beforeIntrospectionForNewDomain_addDefaultCondition() {
     assertThat(newInfo.getDomain(), hasCondition(COMPLETED).withStatus("False"));
   }
 
+  @Test
+  void runStatusInitializationStepWithKubernetesFailure_removeFailedCondition() {
+    newDomain.getOrCreateStatus().addCondition(new DomainCondition(FAILED).withReason(KUBERNETES).withStatus(true));
+    testSupport.addDomainPresenceInfo(newInfo);
+    testSupport.runSteps(DomainStatusUpdater.createStatusInitializationStep(false));
+
+    assertThat(newInfo.getDomain().getStatus(), hasNoCondition(FAILED).withReason(KUBERNETES));
+  }
+
+  @Test
+  void runStatusInitializationStepWithNonKubernetesFailure_dontRemoveFailedCondition() throws JsonProcessingException {
+    newDomain.getOrCreateStatus().addCondition(new DomainCondition(FAILED).withReason(DOMAIN_INVALID).withStatus(true));
+    testSupport.addDomainPresenceInfo(newInfo);
+    testSupport.runSteps(DomainStatusUpdater.createStatusInitializationStep(false));
+
+    assertThat(newInfo.getDomain(), hasCondition(FAILED).withStatus("True"));
+  }
+
   @Test
   void whenDomainHasRunningServersAndExistingTopology_dontRunIntrospectionJob() throws JsonProcessingException {
     establishPreviousIntrospection(null);

operator/src/test/java/oracle/kubernetes/weblogic/domain/model/DomainStatusNoConditionMatcher.java

@@ -0,0 +1,87 @@
+// Copyright (c) 2023, Oracle and/or its affiliates.
+// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+
+package oracle.kubernetes.weblogic.domain.model;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import javax.annotation.Nonnull;
+
+import oracle.kubernetes.utils.OperatorUtils;
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+
+@SuppressWarnings("unused")
+public class DomainStatusNoConditionMatcher extends TypeSafeDiagnosingMatcher<DomainStatus> {
+  private @Nonnull final DomainConditionType unexpectedType;
+  private String unexpectedStatus;
+  private DomainFailureReason unexpectedReason;
+
+  private DomainStatusNoConditionMatcher(@Nonnull DomainConditionType unexpectedType) {
+    this.unexpectedType = unexpectedType;
+  }
+
+  public static DomainStatusNoConditionMatcher hasNoCondition(DomainConditionType type) {
+    return new DomainStatusNoConditionMatcher(type);
+  }
+
+  public DomainStatusNoConditionMatcher withStatus(String status) {
+    unexpectedStatus = status;
+    return this;
+  }
+
+  public DomainStatusNoConditionMatcher withReason(@Nonnull DomainFailureReason reason) {
+    unexpectedReason = reason;
+    return this;
+  }
+
+  @Override
+  protected boolean matchesSafely(DomainStatus item, Description mismatchDescription) {
+    for (DomainCondition condition : item.getConditions()) {
+      if (matches(condition)) {
+        mismatchDescription.appendValueList(
+            "found domain with conditions ", ", ", ".", item.getConditions());
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean matches(DomainCondition condition) {
+    if (unexpectedType != condition.getType()) {
+      return false;
+    }
+    if (unexpectedStatus != null && !unexpectedStatus.equals(condition.getStatus())) {
+      return false;
+    }
+    return unexpectedReason == null || unexpectedReason == condition.getReason();
+  }
+
+  private DomainStatus getStatus(DomainResource domain) {
+    return Optional.ofNullable(domain.getStatus()).orElse(new DomainStatus());
+  }
+
+  @Override
+  public void describeTo(Description description) {
+    describeTo(description, "domain status not containing condition: ");
+  }
+
+  void describeTo(Description description, String commentPrefix) {
+    List<String> expectations = new ArrayList<>();
+    expectations.add(expectation("type", unexpectedType.toString()));
+    if (unexpectedStatus != null) {
+      expectations.add(expectation("status", unexpectedStatus));
+    }
+    if (unexpectedReason != null) {
+      expectations.add(expectation("reason", unexpectedReason.toString()));
+    }
+    description
+        .appendText(commentPrefix)
+        .appendText(OperatorUtils.joinListGrammatically(expectations));
+  }
+
+  private String expectation(String description, String value) {
+    return description + " = '" + value + "'";
+  }
+}