This is an automated email from the ASF dual-hosted git repository.
siddhant 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 5a9dbb8503 HDDS-9729. Provide API to check a container via Replication
Manager (#5632)
5a9dbb8503 is described below
commit 5a9dbb85032cb3c5c6066010c8e9e91c680d6301
Author: Stephen O'Donnell <[email protected]>
AuthorDate: Fri Dec 1 11:55:06 2023 +0000
HDDS-9729. Provide API to check a container via Replication Manager (#5632)
---
.../replication/ContainerCheckRequest.java | 13 ++++++-
.../replication/NullReplicationQueue.java | 40 ++++++++++++++++++++++
.../container/replication/ReplicationManager.java | 29 ++++++++++++++++
.../health/ClosedWithUnhealthyReplicasHandler.java | 6 ++--
.../health/ClosingContainerHandler.java | 7 ++++
.../health/DeletingContainerHandler.java | 6 ++++
.../health/ECReplicationCheckHandler.java | 2 +-
.../replication/health/EmptyContainerHandler.java | 16 +++++----
.../health/MismatchedReplicasHandler.java | 3 ++
.../replication/health/OpenContainerHandler.java | 5 ++-
.../health/QuasiClosedContainerHandler.java | 10 ++++--
.../replication/TestReplicationManager.java | 25 ++++++++++++++
.../TestClosedWithUnhealthyReplicasHandler.java | 13 +++++++
.../health/TestClosingContainerHandler.java | 10 ++++--
.../health/TestDeletingContainerHandler.java | 20 +++++++----
.../health/TestEmptyContainerHandler.java | 18 ++++++++++
.../health/TestMismatchedReplicasHandler.java | 33 ++++++++++++++++++
.../health/TestOpenContainerHandler.java | 16 +++++++++
.../health/TestQuasiClosedContainerHandler.java | 20 +++++++++--
19 files changed, 267 insertions(+), 25 deletions(-)
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerCheckRequest.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerCheckRequest.java
index 9d51e20c33..93035b696c 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerCheckRequest.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ContainerCheckRequest.java
@@ -36,7 +36,7 @@ public final class ContainerCheckRequest {
private final int maintenanceRedundancy;
private final ReplicationManagerReport report;
private final ReplicationQueue replicationQueue;
-
+ private final boolean readOnly;
private ContainerCheckRequest(Builder builder) {
this.containerInfo = builder.containerInfo;
@@ -46,6 +46,7 @@ public final class ContainerCheckRequest {
this.maintenanceRedundancy = builder.maintenanceRedundancy;
this.report = builder.report;
this.replicationQueue = builder.replicationQueue;
+ this.readOnly = builder.readOnly;
}
public List<ContainerReplicaOp> getPendingOps() {
@@ -72,6 +73,10 @@ public final class ContainerCheckRequest {
return replicationQueue;
}
+ public boolean isReadOnly() {
+ return readOnly;
+ }
+
/**
* Builder class for ContainerCheckRequest.
*/
@@ -83,6 +88,7 @@ public final class ContainerCheckRequest {
private int maintenanceRedundancy;
private ReplicationManagerReport report;
private ReplicationQueue replicationQueue;
+ private boolean readOnly = false;
public Builder setContainerInfo(ContainerInfo containerInfo) {
this.containerInfo = containerInfo;
@@ -115,6 +121,11 @@ public final class ContainerCheckRequest {
return this;
}
+ public Builder setReadOnly(boolean readOnly) {
+ this.readOnly = readOnly;
+ return this;
+ }
+
public ContainerCheckRequest build() {
return new ContainerCheckRequest(this);
}
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/NullReplicationQueue.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/NullReplicationQueue.java
new file mode 100644
index 0000000000..4e6148830e
--- /dev/null
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/NullReplicationQueue.java
@@ -0,0 +1,40 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hdds.scm.container.replication;
+
+/**
+ * A class which extents ReplicationQueue and does nothing. This is used when
+ * checking containers in a read-only mode, where we don't want to queue them
+ * for replication.
+ */
+
+public class NullReplicationQueue extends ReplicationQueue {
+
+ @Override
+ public void enqueue(ContainerHealthResult.UnderReplicatedHealthResult
+ underReplicatedHealthResult) {
+ // Do nothing
+ }
+
+ @Override
+ public void enqueue(ContainerHealthResult.OverReplicatedHealthResult
+ overReplicatedHealthResult) {
+ // Do nothing
+ }
+
+}
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ReplicationManager.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ReplicationManager.java
index d34d14ad21..3b9f66595f 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ReplicationManager.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/ReplicationManager.java
@@ -197,6 +197,8 @@ public class ReplicationManager implements SCMService {
private final UnderReplicatedProcessor underReplicatedProcessor;
private final OverReplicatedProcessor overReplicatedProcessor;
private final HealthCheck containerCheckChain;
+ private final ReplicationQueue nullReplicationQueue =
+ new NullReplicationQueue();
/**
* Constructs ReplicationManager instance with the given configuration.
@@ -840,6 +842,12 @@ public class ReplicationManager implements SCMService {
protected void processContainer(ContainerInfo containerInfo,
ReplicationQueue repQueue, ReplicationManagerReport report)
throws ContainerNotFoundException {
+ processContainer(containerInfo, repQueue, report, false);
+ }
+
+ protected boolean processContainer(ContainerInfo containerInfo,
+ ReplicationQueue repQueue, ReplicationManagerReport report,
+ boolean readOnly) throws ContainerNotFoundException {
synchronized (containerInfo) {
ContainerID containerID = containerInfo.containerID();
final boolean isEC = isEC(containerInfo.getReplicationConfig());
@@ -856,6 +864,7 @@ public class ReplicationManager implements SCMService {
.setReport(report)
.setPendingOps(pendingOps)
.setReplicationQueue(repQueue)
+ .setReadOnly(readOnly)
.build();
// This will call the chain of container health handlers in turn which
// will issue commands as needed, update the report and perhaps add
@@ -865,6 +874,7 @@ public class ReplicationManager implements SCMService {
LOG.debug("Container {} had no actions after passing through the " +
"check chain", containerInfo.containerID());
}
+ return handled;
}
}
@@ -969,6 +979,25 @@ public class ReplicationManager implements SCMService {
}
}
+ /**
+ * This method is used to check the container health status. It runs all the
+ * same checks ReplicationManager runs against a container to determine if it
+ * is under replicated or over replicated etc, but in a readOnly mode so no
+ * commands are sent. The passed in ReplicationManagerReport is updated and
+ * the caller can query it on return to see the results of the check.
+ * @param containerInfo The container to check
+ * @param report The instance of the replicationManager report to update with
+ * the results of the check.
+ * @return True if the handler chain took action on the request or false
other
+ * wise. If the method returns false, then the container is deemed
+ * healthy by replication manager.
+ */
+ public boolean checkContainerStatus(ContainerInfo containerInfo,
+ ReplicationManagerReport report) throws ContainerNotFoundException {
+ report.increment(containerInfo.getState());
+ return processContainer(containerInfo, nullReplicationQueue, report, true);
+ }
+
/**
* Retrieve a list of any pending container replications or deletes for the
* given containerID.
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosedWithUnhealthyReplicasHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosedWithUnhealthyReplicasHandler.java
index b5dd9ed3c3..1b23c7580b 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosedWithUnhealthyReplicasHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosedWithUnhealthyReplicasHandler.java
@@ -102,11 +102,13 @@ public class ClosedWithUnhealthyReplicasHandler extends
AbstractCheck {
}
foundUnhealthy = true;
- sendDeleteCommand(containerInfo, replica);
+ if (!request.isReadOnly()) {
+ sendDeleteCommand(containerInfo, replica);
+ }
}
}
- // some unhealthy replicas were found so the container must be over
+ // some unhealthy replicas were found so the container must be
// over replicated due to unhealthy replicas.
if (foundUnhealthy) {
request.getReport().incrementAndSample(
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosingContainerHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosingContainerHandler.java
index 428d12e28e..97beb1dce2 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosingContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/ClosingContainerHandler.java
@@ -70,12 +70,19 @@ public class ClosingContainerHandler extends AbstractCheck {
boolean forceClose = containerInfo.getReplicationConfig()
.getReplicationType() != ReplicationType.RATIS;
+ // TODO - review this logic - may need an empty check here
if (request.getContainerReplicas().isEmpty()) {
request.getReport().incrementAndSample(
ReplicationManagerReport.HealthState.MISSING,
containerInfo.containerID());
}
+ if (request.isReadOnly()) {
+ // The reset of this method modifies container state, so we just return
+ // here if the request is read only.
+ return true;
+ }
+
boolean allUnhealthy = true;
for (ContainerReplica replica : request.getContainerReplicas()) {
if (replica.getState() != ContainerReplicaProto.State.UNHEALTHY) {
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/DeletingContainerHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/DeletingContainerHandler.java
index d4b8b262b5..eaaee48546 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/DeletingContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/DeletingContainerHandler.java
@@ -70,6 +70,12 @@ public class DeletingContainerHandler extends AbstractCheck {
LOG.debug("Checking container {} in DeletingContainerHandler",
containerInfo);
+ if (request.isReadOnly()) {
+ // The reset of this method modifies state, so we just return true if
+ // the request is read only
+ return true;
+ }
+
if (request.getContainerReplicas().size() == 0) {
LOG.debug("Deleting Container {} has no replicas so marking for cleanup"
+
" and returning true", containerInfo);
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 f4677f8215..197b53ed90 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
@@ -131,7 +131,7 @@ public class ECReplicationCheckHandler extends
AbstractCheck {
// 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/
+ // due to decommission
dueToOutOfService = false;
remainingRedundancy = repConfig.getParity() - missingIndexes.size();
}
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/EmptyContainerHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/EmptyContainerHandler.java
index 69804698f2..19f5097a27 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/EmptyContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/EmptyContainerHandler.java
@@ -60,14 +60,16 @@ public class EmptyContainerHandler extends AbstractCheck {
request.getReport()
.incrementAndSample(ReplicationManagerReport.HealthState.EMPTY,
containerInfo.containerID());
- LOG.debug("Container {} is empty and closed, marking as DELETING",
- containerInfo);
- // delete replicas if they are closed and empty
- deleteContainerReplicas(containerInfo, replicas);
+ if (!request.isReadOnly()) {
+ LOG.debug("Container {} is empty and closed, marking as DELETING",
+ containerInfo);
+ // delete replicas if they are closed and empty
+ deleteContainerReplicas(containerInfo, replicas);
- // Update the container's state
- replicationManager.updateContainerState(
- containerInfo.containerID(), HddsProtos.LifeCycleEvent.DELETE);
+ // Update the container's state
+ replicationManager.updateContainerState(
+ containerInfo.containerID(), HddsProtos.LifeCycleEvent.DELETE);
+ }
return true;
} else if (containerInfo.getState() == HddsProtos.LifeCycleState.CLOSED
&& containerInfo.getNumberOfKeys() == 0 && replicas.isEmpty()) {
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/MismatchedReplicasHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/MismatchedReplicasHandler.java
index ecfdf0c90e..68df0e7ed4 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/MismatchedReplicasHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/MismatchedReplicasHandler.java
@@ -68,6 +68,9 @@ public class MismatchedReplicasHandler extends AbstractCheck {
LOG.debug("Checking container {} in MismatchedReplicasHandler",
containerInfo);
+ if (request.isReadOnly()) {
+ return false;
+ }
// close replica if needed
for (ContainerReplica replica : replicas) {
if (shouldBeClosed(containerInfo, replica)) {
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/OpenContainerHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/OpenContainerHandler.java
index a644f5e834..2c0b405db9 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/OpenContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/OpenContainerHandler.java
@@ -62,7 +62,10 @@ public class OpenContainerHandler extends AbstractCheck {
request.getReport().incrementAndSample(
ReplicationManagerReport.HealthState.OPEN_UNHEALTHY,
containerInfo.containerID());
-
replicationManager.sendCloseContainerEvent(containerInfo.containerID());
+ if (!request.isReadOnly()) {
+ replicationManager
+ .sendCloseContainerEvent(containerInfo.containerID());
+ }
return true;
}
// For open containers we do not want to do any further processing in RM
diff --git
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/QuasiClosedContainerHandler.java
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/QuasiClosedContainerHandler.java
index 01f6a05d77..94a93af107 100644
---
a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/QuasiClosedContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/container/replication/health/QuasiClosedContainerHandler.java
@@ -36,6 +36,9 @@ import java.util.stream.Collectors;
* Class for handling containers that are in QUASI_CLOSED state. This will
* send commands to Datanodes to force close these containers if they satisfy
* the requirements to be force closed. Only meant for RATIS containers.
+ *
+ * Note - this handler always returns false so further handlers can can for
+ * under and over replication etc.
*/
public class QuasiClosedContainerHandler extends AbstractCheck {
public static final Logger LOG =
@@ -69,8 +72,9 @@ public class QuasiClosedContainerHandler extends
AbstractCheck {
Set<ContainerReplica> replicas = request.getContainerReplicas();
if (canForceCloseContainer(containerInfo, replicas)) {
- forceCloseContainer(containerInfo, replicas);
- return true;
+ if (!request.isReadOnly()) {
+ forceCloseContainer(containerInfo, replicas);
+ }
} else {
LOG.debug("Container {} cannot be force closed and is stuck in " +
"QUASI_CLOSED", containerInfo);
@@ -78,6 +82,8 @@ public class QuasiClosedContainerHandler extends
AbstractCheck {
ReplicationManagerReport.HealthState.QUASI_CLOSED_STUCK,
containerInfo.containerID());
}
+ // Always return false, even if commands were sent. That way, under and
+ // over replication handlers can to check for other issues in the
container.
return false;
}
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestReplicationManager.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestReplicationManager.java
index f31db93dfb..d2b2d18d35 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestReplicationManager.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/TestReplicationManager.java
@@ -510,6 +510,17 @@ public class TestReplicationManager {
assertEquals(0, repQueue.overReplicatedQueueSize());
}
+ @Test
+ public void testHealthyContainerStatus() throws ContainerNotFoundException {
+ ContainerInfo container = createContainerInfo(repConfig, 1,
+ HddsProtos.LifeCycleState.CLOSED);
+ addReplicas(container, ContainerReplicaProto.State.CLOSED, 1, 2, 3, 4, 5);
+
+ boolean result = replicationManager.checkContainerStatus(
+ container, repReport);
+ assertEquals(false, result);
+ }
+
@Test
public void testUnderReplicatedContainer() throws ContainerNotFoundException
{
ContainerInfo container = createContainerInfo(repConfig, 1,
@@ -524,6 +535,20 @@ public class TestReplicationManager {
ReplicationManagerReport.HealthState.UNDER_REPLICATED));
}
+ @Test
+ public void testUnderReplicatedContainerStatus()
+ throws ContainerNotFoundException {
+ ContainerInfo container = createContainerInfo(repConfig, 1,
+ HddsProtos.LifeCycleState.CLOSED);
+ addReplicas(container, ContainerReplicaProto.State.CLOSED, 1, 2, 3, 4);
+
+ boolean result = replicationManager.checkContainerStatus(
+ container, repReport);
+ assertEquals(1, repReport.getStat(
+ ReplicationManagerReport.HealthState.UNDER_REPLICATED));
+ assertEquals(true, result);
+ }
+
/**
* {@link
* ReplicationManager#getContainerReplicationHealth(ContainerInfo, Set)}
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 073717d26e..921538da94 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
@@ -137,10 +137,23 @@ public class TestClosedWithUnhealthyReplicasHandler {
.setContainerInfo(container)
.build();
+ ContainerCheckRequest readRequest = requestBuilder
+ .setContainerReplicas(containerReplicas)
+ .setContainerInfo(container)
+ .setReadOnly(true)
+ .build();
+
assertTrue(handler.handle(request));
assertEquals(1, request.getReport().getStat(
ReplicationManagerReport.HealthState.OVER_REPLICATED));
+ assertTrue(handler.handle(readRequest));
+ // Same report object is incremented again
+ assertEquals(2, request.getReport().getStat(
+ ReplicationManagerReport.HealthState.OVER_REPLICATED));
+
+ // Only a single delete should be sent, as the read request should not have
+ // triggered one.
ArgumentCaptor<Integer> replicaIndexCaptor =
ArgumentCaptor.forClass(Integer.class);
Mockito.verify(replicationManager, Mockito.times(2))
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosingContainerHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosingContainerHandler.java
index a89730424a..c04b8b2fc7 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosingContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestClosingContainerHandler.java
@@ -191,13 +191,17 @@ public class TestClosingContainerHandler {
ReplicationManagerReport report = new ReplicationManagerReport();
- ContainerCheckRequest request = new ContainerCheckRequest.Builder()
+ ContainerCheckRequest.Builder builder = new ContainerCheckRequest.Builder()
.setPendingOps(Collections.emptyList())
.setReport(report)
.setContainerInfo(containerInfo)
- .setContainerReplicas(containerReplicas)
- .build();
+ .setContainerReplicas(containerReplicas);
+ ContainerCheckRequest request = builder.build();
+
+ builder.setReadOnly(true);
+ ContainerCheckRequest readRequest = builder.build();
+ assertAndVerify(readRequest, true, 0);
assertAndVerify(request, true, 3);
report.getStats().forEach((k, v) -> Assertions.assertEquals(0L, v));
}
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 bc233754f1..fc63a825dc 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
@@ -126,24 +126,32 @@ public class TestDeletingContainerHandler {
HddsProtos.ReplicationFactor.THREE), 1);
//ec container
- //since updateContainerState is called once when testing
- //ratis container, so here should be 1+1 = 2 times
- cleanupIfNoReplicaExist(ecReplicationConfig, 2);
+ cleanupIfNoReplicaExist(ecReplicationConfig, 1);
}
private void cleanupIfNoReplicaExist(
ReplicationConfig replicationConfig, int times) {
+ Mockito.clearInvocations(replicationManager);
ContainerInfo containerInfo = ReplicationTestUtil.createContainerInfo(
replicationConfig, 1, DELETING);
Set<ContainerReplica> containerReplicas = new HashSet<>();
- ContainerCheckRequest request = new ContainerCheckRequest.Builder()
+ ContainerCheckRequest.Builder builder = new ContainerCheckRequest.Builder()
.setPendingOps(Collections.emptyList())
.setReport(new ReplicationManagerReport())
.setContainerInfo(containerInfo)
- .setContainerReplicas(containerReplicas)
- .build();
+ .setContainerReplicas(containerReplicas);
+
+ ContainerCheckRequest request = builder.build();
+
+ builder.setReadOnly(true);
+ ContainerCheckRequest readRequest = builder.build();
+
+ Assertions.assertTrue(deletingContainerHandler.handle(readRequest));
+ Mockito.verify(replicationManager, Mockito.times(0))
+ .updateContainerState(Mockito.any(ContainerID.class),
+ Mockito.any(HddsProtos.LifeCycleEvent.class));
Assertions.assertTrue(deletingContainerHandler.handle(request));
Mockito.verify(replicationManager, Mockito.times(times))
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestEmptyContainerHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestEmptyContainerHandler.java
index 760ec9b7d4..e89164250a 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestEmptyContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestEmptyContainerHandler.java
@@ -87,6 +87,15 @@ public class TestEmptyContainerHandler {
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
+
+ assertAndVerify(readRequest, true, 0, 1);
assertAndVerify(request, true, 5, 1);
}
@@ -109,6 +118,15 @@ public class TestEmptyContainerHandler {
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
+
+ assertAndVerify(readRequest, true, 0, 1);
assertAndVerify(request, true, 3, 1);
}
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestMismatchedReplicasHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestMismatchedReplicasHandler.java
index cb5f4649e4..db875bc688 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestMismatchedReplicasHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestMismatchedReplicasHandler.java
@@ -128,9 +128,18 @@ public class TestMismatchedReplicasHandler {
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
+
// this handler always returns false so other handlers can fix issues
// such as under replication
Assertions.assertFalse(handler.handle(request));
+ Assertions.assertFalse(handler.handle(readRequest));
Mockito.verify(replicationManager, times(1))
.sendCloseContainerReplicaCommand(
@@ -207,10 +216,18 @@ public class TestMismatchedReplicasHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
// this handler always returns false so other handlers can fix issues
// such as under replication
Assertions.assertFalse(handler.handle(request));
+ Assertions.assertFalse(handler.handle(readRequest));
Mockito.verify(replicationManager, times(1))
.sendCloseContainerReplicaCommand(
@@ -254,10 +271,18 @@ public class TestMismatchedReplicasHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
// this handler always returns false so other handlers can fix issues
// such as under replication
Assertions.assertFalse(handler.handle(request));
+ Assertions.assertFalse(handler.handle(readRequest));
Mockito.verify(replicationManager, times(1))
.sendCloseContainerReplicaCommand(
@@ -296,10 +321,18 @@ public class TestMismatchedReplicasHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
// this handler always returns false so other handlers can fix issues
// such as under replication
Assertions.assertFalse(handler.handle(request));
+ Assertions.assertFalse(handler.handle(readRequest));
Mockito.verify(replicationManager, times(1))
.sendCloseContainerReplicaCommand(
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestOpenContainerHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestOpenContainerHandler.java
index 4ed8beea75..32ef98e76a 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestOpenContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestOpenContainerHandler.java
@@ -107,7 +107,15 @@ public class TestOpenContainerHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
Assertions.assertTrue(openContainerHandler.handle(request));
+ Assertions.assertTrue(openContainerHandler.handle(readRequest));
Mockito.verify(replicationManager, times(1))
.sendCloseContainerEvent(containerInfo.containerID());
}
@@ -161,7 +169,15 @@ public class TestOpenContainerHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
Assertions.assertTrue(openContainerHandler.handle(request));
+ Assertions.assertTrue(openContainerHandler.handle(readRequest));
Mockito.verify(replicationManager, times(1))
.sendCloseContainerEvent(Mockito.any());
}
diff --git
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestQuasiClosedContainerHandler.java
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestQuasiClosedContainerHandler.java
index da1b818a06..899b657155 100644
---
a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestQuasiClosedContainerHandler.java
+++
b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/replication/health/TestQuasiClosedContainerHandler.java
@@ -128,8 +128,16 @@ public class TestQuasiClosedContainerHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
- Assertions.assertTrue(quasiClosedContainerHandler.handle(request));
+ Assertions.assertFalse(quasiClosedContainerHandler.handle(request));
+ Assertions.assertFalse(quasiClosedContainerHandler.handle(readRequest));
Mockito.verify(replicationManager, times(2))
.sendCloseContainerReplicaCommand(any(), any(), anyBoolean());
}
@@ -224,8 +232,16 @@ public class TestQuasiClosedContainerHandler {
.setContainerInfo(containerInfo)
.setContainerReplicas(containerReplicas)
.build();
+ ContainerCheckRequest readRequest = new ContainerCheckRequest.Builder()
+ .setPendingOps(Collections.emptyList())
+ .setReport(new ReplicationManagerReport())
+ .setContainerInfo(containerInfo)
+ .setContainerReplicas(containerReplicas)
+ .setReadOnly(true)
+ .build();
- Assertions.assertTrue(quasiClosedContainerHandler.handle(request));
+ Assertions.assertFalse(quasiClosedContainerHandler.handle(request));
+ Assertions.assertFalse(quasiClosedContainerHandler.handle(readRequest));
// verify close command was sent for replicas with sequence ID 1001, that
// is dnTwo and dnThree
Mockito.verify(replicationManager, times(1))
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
