This is an automated email from the ASF dual-hosted git repository.
adoroszlai pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ozone.git
The following commit(s) were added to refs/heads/master by this push:
new f803bdedd9 HDDS-8617. Ratis underreplication due to maintenance is not
deprioritised (#4735)
f803bdedd9 is described below
commit f803bdedd94ef63dfa95edd001aed5940e04a610
Author: Doroszlai, Attila <[email protected]>
AuthorDate: Fri May 19 22:38:45 2023 +0200
HDDS-8617. Ratis underreplication due to maintenance is not deprioritised
(#4735)
---
.../replication/ContainerHealthResult.java | 81 ++--
.../replication/RatisContainerReplicaCount.java | 8 +-
.../health/ECReplicationCheckHandler.java | 6 +-
.../apache/hadoop/hdds/scm/node/NodeStatus.java | 42 +-
.../replication/TestLegacyReplicationManager.java | 2 +-
.../TestRatisContainerReplicaCount.java | 108 ++---
.../TestClosedWithUnhealthyReplicasHandler.java | 24 +-
.../health/TestDeletingContainerHandler.java | 10 +-
.../health/TestECReplicationCheckHandler.java | 328 +++++++--------
.../health/TestRatisReplicationCheckHandler.java | 448 +++++++++++----------
.../TestRatisUnhealthyReplicationCheckHandler.java | 128 +++---
11 files changed, 630 insertions(+), 555 deletions(-)
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerHealthResult.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerHealthResult.java
index 31e35e7e38..25d1d9e439 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerHealthResult.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerHealthResult.java
@@ -76,7 +76,7 @@ public class ContainerHealthResult {
/**
* Class for Unhealthy container check results, where the container has some
- * issue other than over or under replication.
+ * issue other than over- or under-replication.
*/
public static class UnHealthyResult extends ContainerHealthResult {
@@ -91,21 +91,21 @@ public class ContainerHealthResult {
public static class UnderReplicatedHealthResult
extends ContainerHealthResult {
- // For under replicated containers, the best remaining redundancy we can
+ // For under-replicated containers, the best remaining redundancy we can
// have is 3 for EC-10-4, 2 for EC-6-3, 1 for EC-3-2 and 2 for Ratis.
- // A container which is under-replicated due to decommission will have one
- // more, ie 4, 3, 2, 3 respectively. Ideally we want to sort decommission
- // only under-replication after all other under-replicated containers.
+ // A container which is under-replicated due to decommission or maintenance
+ // will have one more, ie 4, 3, 2, 3 respectively. Ideally we want to sort
+ // such under-replication after all other under-replicated containers.
// It may also make sense to allow under-replicated containers a chance to
- // retry once before processing the decommission only under replication.
- // Therefore we should adjust the weighted remaining redundancy of
- // decommission only under-replicated containers to a floor of 5 so they
- // sort after an under-replicated container with 3 remaining replicas (
- // EC-10-4) and plus one retry.
- private static final int DECOMMISSION_REDUNDANCY = 5;
+ // retry once before processing the out-of-service under-replication.
+ // Therefore, we should adjust the weighted remaining redundancy of
+ // containers under-replicated only due to out-of-service to 5, so they
+ // sort after an under-replicated container with 3 remaining replicas
+ // (EC-10-4) and plus one retry.
+ private static final int OUT_OF_SERVICE_REDUNDANCY = 5;
private final int remainingRedundancy;
- private final boolean dueToDecommission;
+ private final boolean dueToOutOfService;
private final boolean sufficientlyReplicatedAfterPending;
private final boolean unrecoverable;
private boolean hasHealthyReplicas;
@@ -113,19 +113,19 @@ public class ContainerHealthResult {
private int requeueCount = 0;
public UnderReplicatedHealthResult(ContainerInfo containerInfo,
- int remainingRedundancy, boolean dueToDecommission,
+ int remainingRedundancy, boolean dueToOutOfService,
boolean replicatedOkWithPending, boolean unrecoverable) {
- this(containerInfo, remainingRedundancy, dueToDecommission,
+ this(containerInfo, remainingRedundancy, dueToOutOfService,
replicatedOkWithPending, unrecoverable,
HealthState.UNDER_REPLICATED);
}
protected UnderReplicatedHealthResult(ContainerInfo containerInfo,
- int remainingRedundancy, boolean dueToDecommission,
+ int remainingRedundancy, boolean dueToOutOfService,
boolean replicatedOkWithPending, boolean unrecoverable,
HealthState healthState) {
super(containerInfo, healthState);
this.remainingRedundancy = remainingRedundancy;
- this.dueToDecommission = dueToDecommission;
+ this.dueToOutOfService = dueToOutOfService;
this.sufficientlyReplicatedAfterPending = replicatedOkWithPending;
this.unrecoverable = unrecoverable;
}
@@ -155,8 +155,8 @@ public class ContainerHealthResult {
*/
public int getWeightedRedundancy() {
int result = requeueCount;
- if (dueToDecommission) {
- result += DECOMMISSION_REDUNDANCY;
+ if (dueToOutOfService) {
+ result += OUT_OF_SERVICE_REDUNDANCY;
} else {
result += getRemainingRedundancy();
}
@@ -183,8 +183,8 @@ public class ContainerHealthResult {
* unavailable.
* @return True is the under-replication is caused by decommission.
*/
- public boolean underReplicatedDueToDecommission() {
- return dueToDecommission;
+ public boolean underReplicatedDueToOutOfService() {
+ return dueToOutOfService;
}
/**
@@ -237,11 +237,38 @@ public class ContainerHealthResult {
public void setHasHealthyReplicas(boolean hasHealthyReplicas) {
this.hasHealthyReplicas = hasHealthyReplicas;
}
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("UnderReplicatedHealthResult{")
+ .append("containerId=").append(getContainerInfo().getContainerID())
+ .append(", state=").append(getHealthState())
+ .append(", remainingRedundancy=").append(remainingRedundancy);
+ if (dueToOutOfService) {
+ sb.append(" +dueToOutOfService");
+ }
+ if (sufficientlyReplicatedAfterPending) {
+ sb.append(" +sufficientlyReplicatedAfterPending");
+ }
+ if (unrecoverable) {
+ sb.append(" +unrecoverable");
+ }
+ if (hasHealthyReplicas) {
+ sb.append(" +hasHealthyReplicas");
+ }
+ if (hasUnReplicatedOfflineIndexes) {
+ sb.append(" +hasUnReplicatedOfflineIndexes");
+ }
+ if (requeueCount > 0) {
+ sb.append(" requeued:").append(requeueCount);
+ }
+ return sb.append("}").toString();
+ }
}
/**
* Class to represent a container healthy state which is mis-Replicated. This
- * means the container is neither over nor under replicated, but its replicas
+ * means the container is neither over- nor under-replicated, but its
replicas
* don't meet the requirements of the container placement policy. Eg the
* containers are not spread across enough racks.
*/
@@ -250,13 +277,13 @@ public class ContainerHealthResult {
/**
* In UnderReplicatedHealthState, DECOMMISSION_REDUNDANCY is defined as
- * 5 so that containers which are really under replicated get fixed as a
+ * 5 so that containers which are really under-replicated get fixed as a
* priority over decommissioning hosts. We have defined that a container
- * can only be mis replicated if it is not over or under replicated. Fixing
- * mis replication is arguably less important than competing a
decommission.
- * So as a lot of mis replicated container do not block decommission, we
- * set the redundancy of mis replicated containers to 6 so they sort after
- * under / over replicated and decommissioning replicas in the under
+ * can only be mis-replicated if it is not over- or under-replicated.
Fixing
+ * mis-replication is arguably less important than completing decommission.
+ * To avoid a lot of mis-replicated containers blocking decommission, we
+ * set the redundancy of mis-replicated containers to 6, so they sort after
+ * under/over-replicated and decommissioning replicas in the under
* replication queue.
*/
private static final int MIS_REP_REDUNDANCY = 6;
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/RatisContainerReplicaCount.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/RatisContainerReplicaCount.java
index e04740ab30..a6e6e390e9 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/RatisContainerReplicaCount.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/RatisContainerReplicaCount.java
@@ -507,14 +507,14 @@ public class RatisContainerReplicaCount implements
ContainerReplicaCount {
/**
* Checks whether insufficient replication is because of some replicas
- * being on datanodes that were decommissioned.
+ * being on datanodes that were decommissioned or are in maintenance.
*
* @return true if there is insufficient replication and it's because of
* decommissioning.
*/
- private boolean inSufficientDueToDecommission() {
+ boolean insufficientDueToOutOfService() {
int delta = redundancyDelta(true, false);
- return 0 < delta && delta <= getDecommissionCount();
+ return 0 < delta && delta <= getDecommissionCount() +
getMaintenanceCount();
}
/**
@@ -548,7 +548,7 @@ public class RatisContainerReplicaCount implements
ContainerReplicaCount {
UnderReplicatedHealthResult result = new UnderReplicatedHealthResult(
getContainer(),
getRemainingRedundancy(),
- inSufficientDueToDecommission(),
+ insufficientDueToOutOfService(),
isSufficientlyReplicated(true),
isUnrecoverable());
result.setHasHealthyReplicas(getHealthyReplicaCount() > 0);
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ECReplicationCheckHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ECReplicationCheckHandler.java
index 1073498c29..55f6c4cdf4 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ECReplicationCheckHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ECReplicationCheckHandler.java
@@ -141,19 +141,19 @@ public class ECReplicationCheckHandler extends
AbstractCheck {
if (!replicaCount.isSufficientlyReplicated(false)) {
List<Integer> missingIndexes = replicaCount.unavailableIndexes(false);
int remainingRedundancy = repConfig.getParity();
- boolean dueToDecommission = true;
+ boolean dueToOutOfService = true;
if (missingIndexes.size() > 0) {
// The container has reduced redundancy and will need reconstructed
// via an EC reconstruction command. Note that it may also have some
// replicas in decommission / maintenance states, but as the under
// replication is not caused only by decommission, we say it is not
// due to decommission/
- dueToDecommission = false;
+ dueToOutOfService = false;
remainingRedundancy = repConfig.getParity() - missingIndexes.size();
}
ContainerHealthResult.UnderReplicatedHealthResult result =
new ContainerHealthResult.UnderReplicatedHealthResult(
- container, remainingRedundancy, dueToDecommission,
+ container, remainingRedundancy, dueToOutOfService,
replicaCount.isSufficientlyReplicated(true),
replicaCount.isUnrecoverable());
if (replicaCount.decommissioningOnlyIndexes(true).size() > 0
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/NodeStatus.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/NodeStatus.java
index 84a411974e..7b1d6dd27d 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/NodeStatus.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/node/NodeStatus.java
@@ -18,9 +18,12 @@
package org.apache.hadoop.hdds.scm.node;
+import com.google.common.collect.ImmutableSet;
import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import java.util.EnumSet;
import java.util.Objects;
+import java.util.Set;
/**
* This class is used to capture the current status of a datanode. This
@@ -30,6 +33,38 @@ import java.util.Objects;
*/
public class NodeStatus implements Comparable<NodeStatus> {
+ private static final Set<HddsProtos.NodeOperationalState>
+ MAINTENANCE_STATES = ImmutableSet.copyOf(EnumSet.of(
+ HddsProtos.NodeOperationalState.ENTERING_MAINTENANCE,
+ HddsProtos.NodeOperationalState.IN_MAINTENANCE
+ ));
+
+ private static final Set<HddsProtos.NodeOperationalState>
+ DECOMMISSION_STATES = ImmutableSet.copyOf(EnumSet.of(
+ HddsProtos.NodeOperationalState.DECOMMISSIONING,
+ HddsProtos.NodeOperationalState.DECOMMISSIONED
+ ));
+
+ private static final Set<HddsProtos.NodeOperationalState>
+ OUT_OF_SERVICE_STATES = ImmutableSet.copyOf(EnumSet.of(
+ HddsProtos.NodeOperationalState.DECOMMISSIONING,
+ HddsProtos.NodeOperationalState.DECOMMISSIONED,
+ HddsProtos.NodeOperationalState.ENTERING_MAINTENANCE,
+ HddsProtos.NodeOperationalState.IN_MAINTENANCE
+ ));
+
+ public static Set<HddsProtos.NodeOperationalState> maintenanceStates() {
+ return MAINTENANCE_STATES;
+ }
+
+ public static Set<HddsProtos.NodeOperationalState> decommissionStates() {
+ return DECOMMISSION_STATES;
+ }
+
+ public static Set<HddsProtos.NodeOperationalState> outOfServiceStates() {
+ return OUT_OF_SERVICE_STATES;
+ }
+
private HddsProtos.NodeOperationalState operationalState;
private HddsProtos.NodeState health;
private long opStateExpiryEpochSeconds;
@@ -104,8 +139,7 @@ public class NodeStatus implements Comparable<NodeStatus> {
* @return True if the node is in any decommission state, false otherwise
*/
public boolean isDecommission() {
- return operationalState == HddsProtos.NodeOperationalState.DECOMMISSIONING
- || operationalState == HddsProtos.NodeOperationalState.DECOMMISSIONED;
+ return DECOMMISSION_STATES.contains(operationalState);
}
/**
@@ -132,9 +166,7 @@ public class NodeStatus implements Comparable<NodeStatus> {
* @return True if the node is in any maintenance state, false otherwise
*/
public boolean isMaintenance() {
- return operationalState
- == HddsProtos.NodeOperationalState.ENTERING_MAINTENANCE
- || operationalState == HddsProtos.NodeOperationalState.IN_MAINTENANCE;
+ return MAINTENANCE_STATES.contains(operationalState);
}
/**
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestLegacyReplicationManager.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestLegacyReplicationManager.java
index 2f4139ee0a..9641cdd7d8 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestLegacyReplicationManager.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestLegacyReplicationManager.java
@@ -1604,7 +1604,7 @@ public class TestLegacyReplicationManager {
* decommissioned replicas.
*/
@Test
- public void testUnderReplicatedDueToDecommission()
+ public void testUnderReplicatedDueToOutOfService()
throws IOException, TimeoutException {
final ContainerInfo container = createContainer(LifeCycleState.CLOSED);
addReplica(container, new NodeStatus(IN_SERVICE, HEALTHY), CLOSED);
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestRatisContainerReplicaCount.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestRatisContainerReplicaCount.java
index cee80925d0..0380f2b8f8 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestRatisContainerReplicaCount.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestRatisContainerReplicaCount.java
@@ -26,6 +26,8 @@ import org.apache.hadoop.hdds.scm.container.ContainerInfo;
import org.apache.hadoop.hdds.scm.container.ContainerReplica;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
import java.util.ArrayList;
import java.util.Collections;
@@ -61,7 +63,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
@Test
@@ -70,7 +72,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, false);
}
@Test
@@ -79,7 +81,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 2, false);
+ validate(rcnt, false, 2, false, false);
}
@Test
@@ -89,7 +91,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 3, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, false);
}
/**
@@ -104,7 +106,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 3, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
/**
@@ -118,7 +120,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 1, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, false);
}
/**
@@ -132,7 +134,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 1, 3, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, false);
}
@Test
@@ -142,7 +144,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, true, -1, true);
+ validate(rcnt, true, -1, true, false);
}
@Test
@@ -152,7 +154,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 1, 3, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
@Test
@@ -162,7 +164,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 2, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, false);
}
@Test
@@ -171,7 +173,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 1, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
@Test
@@ -180,7 +182,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 1, 1, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, false);
}
@Test
@@ -189,7 +191,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 2, 0, 3, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, false);
}
/**
@@ -203,17 +205,18 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
- @Test
- void testOneDecommissionedReplica() {
+ @ParameterizedTest
+
@MethodSource("org.apache.hadoop.hdds.scm.node.NodeStatus#decommissionStates")
+ void testOneDecommissionReplica(HddsProtos.NodeOperationalState state) {
Set<ContainerReplica> replica =
- registerNodes(IN_SERVICE, IN_SERVICE, DECOMMISSIONING);
+ registerNodes(IN_SERVICE, IN_SERVICE, state);
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, true);
}
@Test
@@ -223,17 +226,18 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 3, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, true);
}
- @Test
- void testAllDecommissioned() {
+ @ParameterizedTest
+
@MethodSource("org.apache.hadoop.hdds.scm.node.NodeStatus#decommissionStates")
+ void testAllDecommissioned(HddsProtos.NodeOperationalState state) {
Set<ContainerReplica> replica =
- registerNodes(DECOMMISSIONED, DECOMMISSIONED, DECOMMISSIONED);
+ registerNodes(state, state, state);
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 3, false);
+ validate(rcnt, false, 3, false, true);
}
@Test
@@ -242,7 +246,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 1, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, true);
}
@@ -252,7 +256,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 1, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, true);
}
@Test
@@ -261,21 +265,23 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 1, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
/**
* Maintenance tests from here.
*/
- @Test
- void testOneHealthyTwoMaintenanceMinRepOfTwo() {
+ @ParameterizedTest
+ @MethodSource("org.apache.hadoop.hdds.scm.node.NodeStatus#maintenanceStates")
+ void testOneHealthyTwoMaintenanceMinRepOfTwo(
+ HddsProtos.NodeOperationalState state) {
Set<ContainerReplica> replica =
- registerNodes(IN_SERVICE, IN_MAINTENANCE, IN_MAINTENANCE);
+ registerNodes(IN_SERVICE, state, state);
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, true);
}
@Test
@@ -285,7 +291,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, true);
}
@Test
@@ -295,7 +301,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 1);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
@Test
@@ -305,7 +311,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 3, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, true);
}
@Test
@@ -315,7 +321,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, false, 2, false);
+ validate(rcnt, false, 2, false, true);
}
/**
@@ -330,7 +336,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
/**
@@ -346,7 +352,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 3, 2);
- validate(rcnt, true, -1, true);
+ validate(rcnt, true, -1, true, false);
assertTrue(rcnt.isSafelyOverReplicated());
}
@@ -356,7 +362,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 1, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, true);
}
@Test
@@ -365,7 +371,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 1, 2);
- validate(rcnt, false, 0, false);
+ validate(rcnt, false, 0, false, true);
}
@Test
@@ -374,7 +380,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 0, 0, 1, 2);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
@Test
@@ -385,7 +391,7 @@ class TestRatisContainerReplicaCount {
ContainerInfo container =
createContainer(HddsProtos.LifeCycleState.CLOSED);
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replica, 1, 0, 3, 2);
- validate(rcnt, false, 1, false);
+ validate(rcnt, false, 1, false, true);
}
@Test
@@ -436,7 +442,7 @@ class TestRatisContainerReplicaCount {
RatisContainerReplicaCount rcnt =
new RatisContainerReplicaCount(container, replicas,
Collections.emptyList(), 2, false);
- validate(rcnt, true, 0, false);
+ validate(rcnt, true, 0, false, false);
}
@Test
@@ -566,11 +572,11 @@ class TestRatisContainerReplicaCount {
unhealthyReplica.getDatanodeDetails(), 0));
RatisContainerReplicaCount withoutUnhealthy =
new RatisContainerReplicaCount(container, replicas, ops, 2, false);
- validate(withoutUnhealthy, true, 0, false);
+ validate(withoutUnhealthy, true, 0, false, false);
RatisContainerReplicaCount withUnhealthy =
new RatisContainerReplicaCount(container, replicas, ops, 2, true);
- validate(withUnhealthy, true, 0, false);
+ validate(withUnhealthy, true, 0, false, false);
}
/**
@@ -593,7 +599,7 @@ class TestRatisContainerReplicaCount {
new RatisContainerReplicaCount(container, replicas,
Collections.emptyList(), 2,
false);
- validate(withoutUnhealthy, false, 1, false);
+ validate(withoutUnhealthy, false, 1, false, false);
}
@Test
@@ -657,12 +663,12 @@ class TestRatisContainerReplicaCount {
RatisContainerReplicaCount withoutUnhealthy =
new RatisContainerReplicaCount(container, replicas, ops, 2, false);
- validate(withoutUnhealthy, true, 0, false);
+ validate(withoutUnhealthy, true, 0, false, false);
assertFalse(withoutUnhealthy.isSafelyOverReplicated());
RatisContainerReplicaCount withUnhealthy =
new RatisContainerReplicaCount(container, replicas, ops, 2, true);
- validate(withUnhealthy, true, -1, true);
+ validate(withUnhealthy, true, -1, true, false);
assertFalse(withUnhealthy.isSafelyOverReplicated());
/*
@@ -684,14 +690,14 @@ class TestRatisContainerReplicaCount {
new RatisContainerReplicaCount(container, replicas,
Collections.emptyList(), 2,
false);
- validate(withoutUnhealthy, true, 0, false);
+ validate(withoutUnhealthy, true, 0, false, false);
assertFalse(withoutUnhealthy.isSafelyOverReplicated());
withUnhealthy =
new RatisContainerReplicaCount(container, replicas,
Collections.emptyList(), 2,
true);
- validate(withUnhealthy, true, -1, true);
+ validate(withUnhealthy, true, -1, true, false);
// Violates rule 2
assertFalse(withUnhealthy.isSafelyOverReplicated());
// now check by adding a CLOSED replica
@@ -701,7 +707,7 @@ class TestRatisContainerReplicaCount {
new RatisContainerReplicaCount(container, replicas,
Collections.emptyList(), 2,
true);
- validate(withUnhealthy, true, -2, true);
+ validate(withUnhealthy, true, -2, true, false);
assertTrue(withUnhealthy.isSafelyOverReplicated());
}
@@ -750,10 +756,12 @@ class TestRatisContainerReplicaCount {
private void validate(RatisContainerReplicaCount rcnt,
boolean sufficientlyReplicated, int replicaDelta,
- boolean overReplicated) {
+ boolean overReplicated, boolean insufficientDueToOutOfService) {
assertEquals(sufficientlyReplicated, rcnt.isSufficientlyReplicated());
assertEquals(overReplicated, rcnt.isOverReplicated());
assertEquals(replicaDelta, rcnt.additionalReplicaNeeded());
+ assertEquals(insufficientDueToOutOfService,
+ rcnt.insufficientDueToOutOfService());
}
private Set<ContainerReplica> registerNodes(
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosedWithUnhealthyReplicasHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosedWithUnhealthyReplicasHandler.java
index bf6232329f..f742c6003e 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosedWithUnhealthyReplicasHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosedWithUnhealthyReplicasHandler.java
@@ -31,9 +31,8 @@ import
org.apache.hadoop.hdds.scm.container.replication.ContainerCheckRequest;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationManager;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil;
import org.apache.ratis.protocol.exceptions.NotLeaderException;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
@@ -45,6 +44,9 @@ import static
org.apache.hadoop.hdds.protocol.proto.HddsProtos.LifeCycleState.CL
import static
org.apache.hadoop.hdds.protocol.proto.HddsProtos.NodeOperationalState.IN_SERVICE;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerInfo;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerReplica;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests for {@link ClosedWithUnhealthyReplicasHandler}.
@@ -55,7 +57,7 @@ public class TestClosedWithUnhealthyReplicasHandler {
private ECReplicationConfig ecReplicationConfig;
private ContainerCheckRequest.Builder requestBuilder;
- @Before
+ @BeforeEach
public void setup() {
ecReplicationConfig = new ECReplicationConfig(3, 2);
replicationManager = Mockito.mock(ReplicationManager.class);
@@ -82,7 +84,7 @@ public class TestClosedWithUnhealthyReplicasHandler {
.setContainerInfo(containerInfo)
.build();
- Assert.assertFalse(handler.handle(request));
+ assertFalse(handler.handle(request));
}
@Test
@@ -103,7 +105,7 @@ public class TestClosedWithUnhealthyReplicasHandler {
.setContainerInfo(containerInfo)
.build();
- Assert.assertFalse(handler.handle(request));
+ assertFalse(handler.handle(request));
}
/**
@@ -135,8 +137,8 @@ public class TestClosedWithUnhealthyReplicasHandler {
.setContainerInfo(container)
.build();
- Assert.assertTrue(handler.handle(request));
- Assert.assertEquals(1, request.getReport().getStat(
+ assertTrue(handler.handle(request));
+ assertEquals(1, request.getReport().getStat(
ReplicationManagerReport.HealthState.UNHEALTHY));
ArgumentCaptor<Integer> replicaIndexCaptor =
@@ -146,7 +148,7 @@ public class TestClosedWithUnhealthyReplicasHandler {
DatanodeDetails.class), Mockito.eq(true));
// replica index that delete was sent for should either be 2 or 5
replicaIndexCaptor.getAllValues()
- .forEach(index -> Assert.assertTrue(index == 2 || index == 5));
+ .forEach(index -> assertTrue(index == 2 || index == 5));
}
/**
@@ -167,7 +169,7 @@ public class TestClosedWithUnhealthyReplicasHandler {
.setContainerInfo(container)
.build();
- Assert.assertFalse(handler.handle(request));
+ assertFalse(handler.handle(request));
}
@Test
@@ -189,6 +191,6 @@ public class TestClosedWithUnhealthyReplicasHandler {
.setContainerInfo(container)
.build();
- Assert.assertFalse(handler.handle(request));
+ assertFalse(handler.handle(request));
}
}
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestDeletingContainerHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestDeletingContainerHandler.java
index eeaf290c7b..0cebdc3007 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestDeletingContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestDeletingContainerHandler.java
@@ -33,7 +33,7 @@ import
org.apache.hadoop.hdds.scm.container.replication.ContainerReplicaOp;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationManager;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil;
import org.apache.ratis.protocol.exceptions.NotLeaderException;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@@ -94,7 +94,7 @@ public class TestDeletingContainerHandler {
.setContainerReplicas(containerReplicas)
.build();
- Assert.assertFalse(deletingContainerHandler.handle(request));
+ Assertions.assertFalse(deletingContainerHandler.handle(request));
}
@Test
@@ -112,7 +112,7 @@ public class TestDeletingContainerHandler {
.setContainerReplicas(containerReplicas)
.build();
- Assert.assertFalse(deletingContainerHandler.handle(request));
+ Assertions.assertFalse(deletingContainerHandler.handle(request));
}
/**
@@ -145,7 +145,7 @@ public class TestDeletingContainerHandler {
.setContainerReplicas(containerReplicas)
.build();
- Assert.assertTrue(deletingContainerHandler.handle(request));
+ Assertions.assertTrue(deletingContainerHandler.handle(request));
Mockito.verify(replicationManager, Mockito.times(times))
.updateContainerState(Mockito.any(ContainerID.class),
Mockito.any(HddsProtos.LifeCycleEvent.class));
@@ -229,7 +229,7 @@ public class TestDeletingContainerHandler {
.setContainerReplicas(containerReplicas)
.build();
- Assert.assertTrue(deletingContainerHandler.handle(request));
+ Assertions.assertTrue(deletingContainerHandler.handle(request));
Mockito.verify(replicationManager, Mockito.times(times))
.sendDeleteCommand(Mockito.any(ContainerInfo.class), Mockito.anyInt(),
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestECReplicationCheckHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestECReplicationCheckHandler.java
index 850e975b22..33c8dd753b 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestECReplicationCheckHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestECReplicationCheckHandler.java
@@ -36,9 +36,8 @@ import
org.apache.hadoop.hdds.scm.container.replication.ContainerHealthResult.He
import org.apache.hadoop.hdds.scm.container.replication.ContainerReplicaOp;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationQueue;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.util.ArrayList;
@@ -58,6 +57,9 @@ import static
org.apache.hadoop.hdds.scm.container.replication.ContainerReplicaO
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerInfo;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerReplica;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createReplicas;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyList;
@@ -74,7 +76,7 @@ public class TestECReplicationCheckHandler {
private ReplicationManagerReport report;
private PlacementPolicy placementPolicy;
- @Before
+ @BeforeEach
public void setup() {
placementPolicy = Mockito.mock(PlacementPolicy.class);
Mockito.when(placementPolicy.validateContainerPlacement(
@@ -102,11 +104,11 @@ public class TestECReplicationCheckHandler {
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
- Assert.assertFalse(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertFalse(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
}
@Test
@@ -120,15 +122,15 @@ public class TestECReplicationCheckHandler {
.build();
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -147,22 +149,22 @@ public class TestECReplicationCheckHandler {
.build();
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
- Assert.assertTrue(healthCheck.handle(request));
+ assertTrue(healthCheck.handle(request));
// Fixed with pending so nothing added to the queue
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
// Still under replicated until the pending complete
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
- public void testUnderReplicatedDueToDecommission() {
+ public void testUnderReplicatedDueToOutOfService() {
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
Pair.of(IN_SERVICE, 1), Pair.of(IN_SERVICE, 2),
@@ -175,21 +177,21 @@ public class TestECReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(2, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(2, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertTrue(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
// Still under replicated until the pending complete
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
- public void testUnderReplicatedDueToDecommissionFixedWithPending() {
+ public void testUnderReplicatedDueToOutOfServiceFixedWithPending() {
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
Pair.of(IN_SERVICE, 1), Pair.of(IN_SERVICE, 2),
@@ -206,22 +208,22 @@ public class TestECReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(2, result.getRemainingRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertTrue(result.underReplicatedDueToDecommission());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(2, result.getRemainingRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+ assertTrue(result.underReplicatedDueToOutOfService());
- Assert.assertTrue(healthCheck.handle(request));
+ assertTrue(healthCheck.handle(request));
// Fixed with pending so nothing added to the queue
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
// Still under replicated until the pending complete
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
- public void testUnderReplicatedDueToDecommissionAndMissingReplica() {
+ public void testUnderReplicatedDueToOutOfServiceAndMissingReplica() {
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
Pair.of(IN_SERVICE, 1), Pair.of(IN_SERVICE, 2),
@@ -237,15 +239,15 @@ public class TestECReplicationCheckHandler {
.build();
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -261,19 +263,19 @@ public class TestECReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(-1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
- Assert.assertTrue(result.isUnrecoverable());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(-1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+ assertTrue(result.isUnrecoverable());
- Assert.assertTrue(healthCheck.handle(request));
+ assertTrue(healthCheck.handle(request));
// Unrecoverable so not added to the queue
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MISSING));
}
@@ -299,20 +301,20 @@ public class TestECReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(-1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
- Assert.assertTrue(result.isUnrecoverable());
- Assert.assertTrue(result.hasUnreplicatedOfflineIndexes());
-
- Assert.assertTrue(healthCheck.handle(request));
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(-1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+ assertTrue(result.isUnrecoverable());
+ assertTrue(result.hasUnreplicatedOfflineIndexes());
+
+ assertTrue(healthCheck.handle(request));
// Unrecoverable so not added to the queue
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MISSING));
}
@@ -342,20 +344,20 @@ public class TestECReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(-1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
- Assert.assertTrue(result.isUnrecoverable());
- Assert.assertFalse(result.hasUnreplicatedOfflineIndexes());
-
- Assert.assertTrue(healthCheck.handle(request));
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(-1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+ assertTrue(result.isUnrecoverable());
+ assertFalse(result.hasUnreplicatedOfflineIndexes());
+
+ assertTrue(healthCheck.handle(request));
// Unrecoverable so not added to the queue
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MISSING));
}
@@ -387,15 +389,15 @@ public class TestECReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(0, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(0, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -424,11 +426,11 @@ public class TestECReplicationCheckHandler {
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
- Assert.assertFalse(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertFalse(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
}
@Test
@@ -447,14 +449,14 @@ public class TestECReplicationCheckHandler {
OverReplicatedHealthResult result = (OverReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
- Assert.assertEquals(2, result.getExcessRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
-
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(2, result.getExcessRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+
+ assertTrue(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -480,14 +482,14 @@ public class TestECReplicationCheckHandler {
OverReplicatedHealthResult result = (OverReplicatedHealthResult)
healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
- Assert.assertEquals(2, result.getExcessRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
-
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(2, result.getExcessRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+
+ assertTrue(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -504,14 +506,14 @@ public class TestECReplicationCheckHandler {
.setContainerInfo(container)
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
// As it is maintenance replicas causing the over replication, the
container
// is not really over-replicated.
- Assert.assertFalse(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertFalse(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -527,18 +529,18 @@ public class TestECReplicationCheckHandler {
.setContainerInfo(container)
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1,
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1,
((UnderReplicatedHealthResult)result).getRemainingRedundancy());
// Under-replicated takes precedence and the over-replication is ignored
// for now.
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -563,16 +565,16 @@ public class TestECReplicationCheckHandler {
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -608,18 +610,18 @@ public class TestECReplicationCheckHandler {
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
// Under-replicated takes precedence and the over-replication is ignored
// for now.
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertTrue(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -643,18 +645,18 @@ public class TestECReplicationCheckHandler {
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
// Under-replicated takes precedence and the over-replication is ignored
// for now.
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(healthCheck.handle(request));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -679,18 +681,18 @@ public class TestECReplicationCheckHandler {
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
// Under-replicated takes precedence and the over-replication is ignored
// for now.
- Assert.assertTrue(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertTrue(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -718,14 +720,14 @@ public class TestECReplicationCheckHandler {
.setPendingOps(pendingOps)
.build();
ContainerHealthResult result = healthCheck.checkHealth(request);
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
- Assert.assertFalse(healthCheck.handle(request));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertFalse(healthCheck.handle(request));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisReplicationCheckHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisReplicationCheckHandler.java
index e0605469a3..a960e6549c 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisReplicationCheckHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisReplicationCheckHandler.java
@@ -37,9 +37,10 @@ import
org.apache.hadoop.hdds.scm.container.replication.ContainerHealthResult.Ov
import
org.apache.hadoop.hdds.scm.container.replication.ContainerHealthResult.UnderReplicatedHealthResult;
import org.apache.hadoop.hdds.scm.container.replication.ContainerReplicaOp;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationQueue;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mockito;
import java.io.IOException;
@@ -58,6 +59,9 @@ import static
org.apache.hadoop.hdds.scm.container.replication.ContainerReplicaO
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerInfo;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerReplica;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createReplicas;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests for the RatisReplicationCheckHandler class.
@@ -72,7 +76,7 @@ public class TestRatisReplicationCheckHandler {
private ReplicationManagerReport report;
private int maintenanceRedundancy = 2;
- @Before
+ @BeforeEach
public void setup() throws IOException {
containerPlacementPolicy = Mockito.mock(PlacementPolicy.class);
Mockito.when(containerPlacementPolicy.validateContainerPlacement(
@@ -100,9 +104,9 @@ public class TestRatisReplicationCheckHandler {
requestBuilder.setContainerReplicas(replicas)
.setContainerInfo(container);
- Assert.assertFalse(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertFalse(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
}
@Test
@@ -114,11 +118,11 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
ContainerHealthResult result =
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
- Assert.assertFalse(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertFalse(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
}
@Test
@@ -130,15 +134,15 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -155,15 +159,15 @@ public class TestRatisReplicationCheckHandler {
.setPendingOps(pending);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -180,22 +184,22 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertTrue(healthCheck.handle(requestBuilder.build()));
// Fixed with pending, so nothing added to the queue
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
// Still under replicated until the pending complete
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
- public void testUnderReplicatedDueToDecommission() {
+ public void testUnderReplicatedDueToOutOfService() {
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
Pair.of(IN_SERVICE, 0), Pair.of(DECOMMISSIONING, 0),
@@ -205,26 +209,27 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(2, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(2, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertTrue(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
- @Test
- public void testUnderReplicatedDueToAllDecommissioning() {
- Pair<HddsProtos.NodeOperationalState, Integer> state =
- Pair.of(DECOMMISSIONING, 0);
+ @ParameterizedTest
+
@MethodSource("org.apache.hadoop.hdds.scm.node.NodeStatus#outOfServiceStates")
+ void testUnderReplicatedDueToAllOutOfService(
+ HddsProtos.NodeOperationalState state) {
+ Pair<HddsProtos.NodeOperationalState, Integer> pair = Pair.of(state, 0);
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
- state, state, state);
+ pair, pair, pair);
ContainerCheckRequest checkRequest = requestBuilder
.setContainerReplicas(replicas)
@@ -232,26 +237,24 @@ public class TestRatisReplicationCheckHandler {
.build();
ContainerHealthResult healthResult = healthCheck.checkHealth(checkRequest);
- Assert.assertEquals(HealthState.UNDER_REPLICATED,
- healthResult.getHealthState());
- Assert.assertEquals(UnderReplicatedHealthResult.class,
- healthResult.getClass());
+ assertEquals(HealthState.UNDER_REPLICATED, healthResult.getHealthState());
+ assertEquals(UnderReplicatedHealthResult.class, healthResult.getClass());
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthResult;
- Assert.assertEquals(2, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(result.underReplicatedDueToDecommission());
+ assertEquals(2, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertTrue(result.underReplicatedDueToOutOfService());
- Assert.assertTrue(healthCheck.handle(checkRequest));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(healthCheck.handle(checkRequest));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
- public void testUnderReplicatedDueToDecommissionFixedWithPending() {
+ public void testUnderReplicatedDueToOutOfServiceFixedWithPending() {
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
Pair.of(IN_SERVICE, 0), Pair.of(IN_SERVICE, 0),
@@ -265,22 +268,22 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(2, result.getRemainingRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertTrue(result.underReplicatedDueToDecommission());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(2, result.getRemainingRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+ assertTrue(result.underReplicatedDueToOutOfService());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertTrue(healthCheck.handle(requestBuilder.build()));
// Nothing queued as inflight replicas will fix it.
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
// Still under replicated in the report until pending complete
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
- public void testUnderReplicatedDueToDecommissionAndMissing() {
+ public void testUnderReplicatedDueToOutOfServiceAndMissing() {
ContainerInfo container = createContainerInfo(repConfig);
Set<ContainerReplica> replicas = createReplicas(container.containerID(),
Pair.of(IN_SERVICE, 0), Pair.of(DECOMMISSIONED, 0));
@@ -293,40 +296,39 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@Test
public void testUnderReplicatedAndUnrecoverable() {
ContainerInfo container = createContainerInfo(repConfig);
- Set<ContainerReplica> replicas = Collections.EMPTY_SET;
- requestBuilder.setContainerReplicas(replicas)
+ requestBuilder.setContainerReplicas(Collections.emptySet())
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(0, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
- Assert.assertTrue(result.isUnrecoverable());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(0, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+ assertTrue(result.isUnrecoverable());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertTrue(healthCheck.handle(requestBuilder.build()));
// Unrecoverable, so not added to the queue.
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MISSING));
}
@@ -348,15 +350,15 @@ public class TestRatisReplicationCheckHandler {
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -370,11 +372,11 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
ContainerHealthResult result =
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
- Assert.assertFalse(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertFalse(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
}
@Test
@@ -392,15 +394,15 @@ public class TestRatisReplicationCheckHandler {
healthy replicas. This handler cannot make a decision about
replication/deleting replicas when all of them are unhealthy.
*/
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(0, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertFalse(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(0, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertFalse(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
/*
@@ -414,15 +416,15 @@ public class TestRatisReplicationCheckHandler {
result = (UnderReplicatedHealthResult) healthCheck.checkHealth(
requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(0, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(0, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
- Assert.assertFalse(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertFalse(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -446,14 +448,14 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
OverReplicatedHealthResult result = (OverReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
- Assert.assertEquals(4, result.getExcessRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(4, result.getExcessRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -470,19 +472,19 @@ public class TestRatisReplicationCheckHandler {
OverReplicatedHealthResult result = (OverReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getExcessRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getExcessRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
/*
We have an excess replica, but we hold off on adding to the over
replication queue until all the mismatched replicas match the container
state.
*/
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -512,21 +514,21 @@ public class TestRatisReplicationCheckHandler {
healthCheck.checkHealth(requestBuilder.build());
// there's an excess of 3 UNHEALTHY replicas, so it's over replicated
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
OverReplicatedHealthResult overRepResult =
(OverReplicatedHealthResult) result;
- Assert.assertEquals(3, overRepResult.getExcessRedundancy());
- Assert.assertTrue(overRepResult.hasMismatchedReplicas());
- Assert.assertFalse(overRepResult.isReplicatedOkAfterPending());
+ assertEquals(3, overRepResult.getExcessRedundancy());
+ assertTrue(overRepResult.hasMismatchedReplicas());
+ assertFalse(overRepResult.isReplicatedOkAfterPending());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
// it should not be queued for over replication because there's a mis
// matched replica
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -550,19 +552,19 @@ public class TestRatisReplicationCheckHandler {
healthCheck.checkHealth(requestBuilder.build());
// there's an excess of 3 UNHEALTHY replicas, so it's over replicated
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
OverReplicatedHealthResult overRepResult =
(OverReplicatedHealthResult) result;
- Assert.assertEquals(3, overRepResult.getExcessRedundancy());
- Assert.assertFalse(overRepResult.hasMismatchedReplicas());
- Assert.assertFalse(overRepResult.isReplicatedOkAfterPending());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(3, overRepResult.getExcessRedundancy());
+ assertFalse(overRepResult.hasMismatchedReplicas());
+ assertFalse(overRepResult.isReplicatedOkAfterPending());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -583,16 +585,16 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
OverReplicatedHealthResult result = (OverReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getExcessRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getExcessRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
// Fixed by pending so nothing queued.
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
// Still over replicated, so the report should contain it
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -608,14 +610,14 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
OverReplicatedHealthResult result = (OverReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getExcessRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getExcessRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
}
@@ -631,14 +633,14 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
ContainerHealthResult result =
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.HEALTHY, result.getHealthState());
+ assertEquals(HealthState.HEALTHY, result.getHealthState());
- Assert.assertFalse(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertFalse(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
@@ -666,21 +668,21 @@ public class TestRatisReplicationCheckHandler {
healthCheck.checkHealth(requestBuilder.build());
// there's an excess of 3 UNHEALTHY replicas, so it's over replicated
- Assert.assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
+ assertEquals(HealthState.OVER_REPLICATED, result.getHealthState());
OverReplicatedHealthResult overRepResult =
(OverReplicatedHealthResult) result;
- Assert.assertEquals(3, overRepResult.getExcessRedundancy());
- Assert.assertFalse(overRepResult.hasMismatchedReplicas());
- Assert.assertFalse(overRepResult.isReplicatedOkAfterPending());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(3, overRepResult.getExcessRedundancy());
+ assertFalse(overRepResult.hasMismatchedReplicas());
+ assertFalse(overRepResult.isReplicatedOkAfterPending());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -699,17 +701,17 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -743,17 +745,17 @@ public class TestRatisReplicationCheckHandler {
.setPendingOps(pending);
UnderReplicatedHealthResult result = (UnderReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(HealthState.UNDER_REPLICATED, result.getHealthState());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(0, report.getStat(
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -772,15 +774,15 @@ public class TestRatisReplicationCheckHandler {
.setContainerInfo(container);
MisReplicatedHealthResult result = (MisReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
+ assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
+ assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
@@ -814,15 +816,15 @@ public class TestRatisReplicationCheckHandler {
.setPendingOps(pending);
MisReplicatedHealthResult result = (MisReplicatedHealthResult)
healthCheck.checkHealth(requestBuilder.build());
- Assert.assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
+ assertEquals(HealthState.MIS_REPLICATED, result.getHealthState());
+ assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertTrue(healthCheck.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(0, report.getStat(
+ assertTrue(healthCheck.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(0, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.MIS_REPLICATED));
}
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisUnhealthyReplicationCheckHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisUnhealthyReplicationCheckHandler.java
index e9e55ab0dc..f17cef2a0d 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisUnhealthyReplicationCheckHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestRatisUnhealthyReplicationCheckHandler.java
@@ -31,9 +31,8 @@ import
org.apache.hadoop.hdds.scm.container.replication.ContainerCheckRequest;
import org.apache.hadoop.hdds.scm.container.replication.ContainerHealthResult;
import org.apache.hadoop.hdds.scm.container.replication.ContainerReplicaOp;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationQueue;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Collections;
@@ -45,6 +44,9 @@ import static
org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerInfo;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createContainerReplica;
import static
org.apache.hadoop.hdds.scm.container.replication.ReplicationTestUtil.createReplicas;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests for {@link RatisUnhealthyReplicationCheckHandler}.
@@ -57,7 +59,7 @@ public class TestRatisUnhealthyReplicationCheckHandler {
private ReplicationManagerReport report;
private int maintenanceRedundancy = 2;
- @Before
+ @BeforeEach
public void setup() throws IOException {
handler = new RatisUnhealthyReplicationCheckHandler();
repConfig = RatisReplicationConfig.getInstance(THREE);
@@ -79,9 +81,9 @@ public class TestRatisUnhealthyReplicationCheckHandler {
requestBuilder.setContainerReplicas(replicas)
.setContainerInfo(container);
- Assert.assertFalse(handler.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertFalse(handler.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
}
@Test
@@ -94,7 +96,7 @@ public class TestRatisUnhealthyReplicationCheckHandler {
requestBuilder.setContainerReplicas(replicas)
.setContainerInfo(container);
- Assert.assertFalse(handler.handle(requestBuilder.build()));
+ assertFalse(handler.handle(requestBuilder.build()));
}
@Test
@@ -107,7 +109,7 @@ public class TestRatisUnhealthyReplicationCheckHandler {
requestBuilder.setContainerReplicas(replicas)
.setContainerInfo(container);
- Assert.assertFalse(handler.handle(requestBuilder.build()));
+ assertFalse(handler.handle(requestBuilder.build()));
}
@Test
@@ -125,7 +127,7 @@ public class TestRatisUnhealthyReplicationCheckHandler {
requestBuilder.setContainerReplicas(replicas)
.setContainerInfo(container);
- Assert.assertFalse(handler.handle(requestBuilder.build()));
+ assertFalse(handler.handle(requestBuilder.build()));
}
@Test
@@ -145,17 +147,17 @@ public class TestRatisUnhealthyReplicationCheckHandler {
ContainerHealthResult.OverReplicatedHealthResult result =
(ContainerHealthResult.OverReplicatedHealthResult)
handler.checkReplication(requestBuilder.build());
- Assert.assertEquals(ContainerHealthResult.HealthState.OVER_REPLICATED,
+ assertEquals(ContainerHealthResult.HealthState.OVER_REPLICATED,
result.getHealthState());
- Assert.assertEquals(1, result.getExcessRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
+ assertEquals(1, result.getExcessRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(handler.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(1, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(handler.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(1, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(1,
+ assertEquals(1,
report.getStat(ReplicationManagerReport.HealthState.UNHEALTHY));
}
@@ -178,18 +180,18 @@ public class TestRatisUnhealthyReplicationCheckHandler {
result = (ContainerHealthResult.UnderReplicatedHealthResult)
handler.checkReplication(requestBuilder.build());
- Assert.assertEquals(ContainerHealthResult.HealthState.UNDER_REPLICATED,
+ assertEquals(ContainerHealthResult.HealthState.UNDER_REPLICATED,
result.getHealthState());
- Assert.assertEquals(0, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(handler.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(0, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(handler.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1,
+ assertEquals(1,
report.getStat(ReplicationManagerReport.HealthState.UNHEALTHY));
}
@@ -212,18 +214,18 @@ public class TestRatisUnhealthyReplicationCheckHandler {
result = (ContainerHealthResult.UnderReplicatedHealthResult)
handler.checkReplication(requestBuilder.build());
- Assert.assertEquals(ContainerHealthResult.HealthState.UNDER_REPLICATED,
+ assertEquals(ContainerHealthResult.HealthState.UNDER_REPLICATED,
result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertFalse(result.underReplicatedDueToDecommission());
-
- Assert.assertTrue(handler.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertEquals(1, result.getRemainingRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
+ assertFalse(result.underReplicatedDueToOutOfService());
+
+ assertTrue(handler.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1,
+ assertEquals(1,
report.getStat(ReplicationManagerReport.HealthState.UNHEALTHY));
}
@@ -246,17 +248,17 @@ public class TestRatisUnhealthyReplicationCheckHandler {
result = (ContainerHealthResult.UnderReplicatedHealthResult)
handler.checkReplication(requestBuilder.build());
- Assert.assertEquals(ContainerHealthResult.HealthState.UNDER_REPLICATED,
+ assertEquals(ContainerHealthResult.HealthState.UNDER_REPLICATED,
result.getHealthState());
- Assert.assertEquals(1, result.getRemainingRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
+ assertEquals(1, result.getRemainingRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
- Assert.assertTrue(handler.handle(requestBuilder.build()));
- Assert.assertEquals(1, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(handler.handle(requestBuilder.build()));
+ assertEquals(1, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
- Assert.assertEquals(1,
+ assertEquals(1,
report.getStat(ReplicationManagerReport.HealthState.UNHEALTHY));
}
@@ -279,17 +281,17 @@ public class TestRatisUnhealthyReplicationCheckHandler {
result = (ContainerHealthResult.OverReplicatedHealthResult)
handler.checkReplication(requestBuilder.build());
- Assert.assertEquals(ContainerHealthResult.HealthState.OVER_REPLICATED,
+ assertEquals(ContainerHealthResult.HealthState.OVER_REPLICATED,
result.getHealthState());
- Assert.assertEquals(1, result.getExcessRedundancy());
- Assert.assertTrue(result.isReplicatedOkAfterPending());
+ assertEquals(1, result.getExcessRedundancy());
+ assertTrue(result.isReplicatedOkAfterPending());
- Assert.assertTrue(handler.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(handler.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(1,
+ assertEquals(1,
report.getStat(ReplicationManagerReport.HealthState.UNHEALTHY));
}
@@ -315,20 +317,20 @@ public class TestRatisUnhealthyReplicationCheckHandler {
result = (ContainerHealthResult.OverReplicatedHealthResult)
handler.checkReplication(requestBuilder.build());
- Assert.assertEquals(ContainerHealthResult.HealthState.OVER_REPLICATED,
+ assertEquals(ContainerHealthResult.HealthState.OVER_REPLICATED,
result.getHealthState());
- Assert.assertEquals(1, result.getExcessRedundancy());
- Assert.assertFalse(result.isReplicatedOkAfterPending());
+ assertEquals(1, result.getExcessRedundancy());
+ assertFalse(result.isReplicatedOkAfterPending());
// not safe for over replication because we don't have 3 matching replicas
- Assert.assertFalse(result.isSafelyOverReplicated());
+ assertFalse(result.isSafelyOverReplicated());
- Assert.assertTrue(handler.handle(requestBuilder.build()));
- Assert.assertEquals(0, repQueue.underReplicatedQueueSize());
- Assert.assertEquals(0, repQueue.overReplicatedQueueSize());
- Assert.assertEquals(1, report.getStat(
+ assertTrue(handler.handle(requestBuilder.build()));
+ assertEquals(0, repQueue.underReplicatedQueueSize());
+ assertEquals(0, repQueue.overReplicatedQueueSize());
+ assertEquals(1, report.getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
- Assert.assertEquals(1,
+ assertEquals(1,
report.getStat(ReplicationManagerReport.HealthState.UNHEALTHY));
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
