> deletedBlocksMap = new HashMap<>();
- deletedBlocksMap.put(containerID, new LinkedList<>());
+ Random random = new Random();
+ long localId = random.nextLong();
+ deletedBlocksMap.put(containerID, new LinkedList<>(
+ Collections.singletonList(localId)));
addTransactions(deletedBlocksMap, true);
+ blocks = getTransactions(txNum * BLOCKS_PER_TXN * ONE);
+ // Only newly added Blocks will be sent, as previously sent transactions
+ // that have not yet timed out will not be sent.
+ Assertions.assertEquals(1, blocks.size());
+ Assertions.assertEquals(1, blocks.get(0).getLocalIDCount());
+ Assertions.assertEquals(blocks.get(0).getLocalID(0), localId);
+ // Lets the SCM delete the transaction and wait for the DN reply
+ // to timeout, thus allowing the transaction to resend the
+ deletedBlockLog.setScmCommandTimeoutMs(-1L);
// get should return two transactions for the same container
blocks = getTransactions(txNum * BLOCKS_PER_TXN * ONE);
Assertions.assertEquals(2, blocks.size());
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/block/TestSCMBlockDeletingService.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/block/TestSCMBlockDeletingService.java
new file mode 100644
index 000000000000..3bd7ad00f6a8
--- /dev/null
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/block/TestSCMBlockDeletingService.java
@@ -0,0 +1,177 @@
+/**
+ * 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.block;
+
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.conf.ReconfigurationHandler;
+import org.apache.hadoop.hdds.protocol.DatanodeDetails;
+import org.apache.hadoop.hdds.protocol.MockDatanodeDetails;
+import org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.SCMCommandProto.Type;
+import org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.DeletedBlocksTransaction;
+import org.apache.hadoop.hdds.scm.ScmConfig;
+import org.apache.hadoop.hdds.scm.events.SCMEvents;
+import org.apache.hadoop.hdds.scm.ha.SCMContext;
+import org.apache.hadoop.hdds.scm.ha.SCMServiceManager;
+import org.apache.hadoop.hdds.scm.node.NodeManager;
+import org.apache.hadoop.hdds.scm.node.NodeStatus;
+import org.apache.hadoop.hdds.server.events.EventPublisher;
+import org.apache.hadoop.ozone.container.common.statemachine.DatanodeConfiguration;
+import org.apache.hadoop.ozone.protocol.commands.CommandForDatanode;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.time.Clock;
+import java.time.ZoneOffset;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test SCMBlockDeletingService.
+ */
+public class TestSCMBlockDeletingService {
+ private SCMBlockDeletingService service;
+ private EventPublisher eventPublisher;
+ private List datanodeDetails;
+ private OzoneConfiguration conf;
+ private NodeManager nodeManager;
+ private ScmBlockDeletingServiceMetrics metrics;
+
+ @BeforeEach
+ public void setup() throws Exception {
+ nodeManager = mock(NodeManager.class);
+ eventPublisher = mock(EventPublisher.class);
+ conf = new OzoneConfiguration();
+ metrics = ScmBlockDeletingServiceMetrics.create();
+ when(nodeManager.getTotalDatanodeCommandCount(any(),
+ any())).thenReturn(0);
+ SCMServiceManager scmServiceManager = mock(SCMServiceManager.class);
+ SCMContext scmContext = mock(SCMContext.class);
+
+ DatanodeDeletedBlockTransactions ddbt =
+ new DatanodeDeletedBlockTransactions();
+ DatanodeDetails datanode1 = MockDatanodeDetails.randomDatanodeDetails();
+ DatanodeDetails datanode2 = MockDatanodeDetails.randomDatanodeDetails();
+ DatanodeDetails datanode3 = MockDatanodeDetails.randomDatanodeDetails();
+ datanodeDetails = Arrays.asList(datanode1, datanode2, datanode3);
+ when(nodeManager.getNodes(NodeStatus.inServiceHealthy())).thenReturn(
+ datanodeDetails);
+ DeletedBlocksTransaction tx1 = createTestDeleteTxn(1, Arrays.asList(1L), 1);
+ ddbt.addTransactionToDN(datanode1.getUuid(), tx1);
+ ddbt.addTransactionToDN(datanode2.getUuid(), tx1);
+ ddbt.addTransactionToDN(datanode3.getUuid(), tx1);
+ DeletedBlockLog mockDeletedBlockLog = mock(DeletedBlockLog.class);
+ when(mockDeletedBlockLog.getTransactions(
+ anyInt(), anySet())).thenReturn(ddbt);
+
+ service = spy(new SCMBlockDeletingService(
+ mockDeletedBlockLog, nodeManager, eventPublisher, scmContext,
+ scmServiceManager, conf, conf.getObject(ScmConfig.class), metrics, Clock.system(
+ ZoneOffset.UTC), mock(ReconfigurationHandler.class)));
+ when(service.shouldRun()).thenReturn(true);
+ }
+
+ @AfterEach
+ public void stop() {
+ service.stop();
+ ScmBlockDeletingServiceMetrics.unRegister();
+ }
+
+ @Test
+ public void testCall() throws Exception {
+ callDeletedBlockTransactionScanner();
+
+ ArgumentCaptor argumentCaptor =
+ ArgumentCaptor.forClass(CommandForDatanode.class);
+
+ // Three Datanode is healthy and in-service, and the task queue is empty,
+ // so the transaction will send to all three Datanode
+ verify(eventPublisher, times(3)).fireEvent(
+ eq(SCMEvents.DATANODE_COMMAND), argumentCaptor.capture());
+ List actualCommands = argumentCaptor.getAllValues();
+ List actualDnIds = actualCommands.stream()
+ .map(CommandForDatanode::getDatanodeId)
+ .collect(Collectors.toList());
+ Set expectedDnIdsSet = datanodeDetails.stream()
+ .map(DatanodeDetails::getUuid).collect(Collectors.toSet());
+
+ assertEquals(expectedDnIdsSet, new HashSet<>(actualDnIds));
+ assertEquals(datanodeDetails.size(),
+ metrics.getNumBlockDeletionCommandSent());
+ // Echo Command has one Transaction
+ assertEquals(datanodeDetails.size() * 1,
+ metrics.getNumBlockDeletionTransactionSent());
+ }
+
+ private void callDeletedBlockTransactionScanner() throws Exception {
+ service.getTasks().poll().call();
+ }
+
+ @Test
+ public void testLimitCommandSending() throws Exception {
+ DatanodeConfiguration dnConf =
+ conf.getObject(DatanodeConfiguration.class);
+ int pendingCommandLimit = dnConf.getBlockDeleteQueueLimit();
+
+ // The number of commands pending on all Datanodes has reached the limit.
+ when(nodeManager.getTotalDatanodeCommandCount(any(),
+ any())).thenReturn(pendingCommandLimit);
+ assertEquals(0,
+ service.getDatanodesWithinCommandLimit(datanodeDetails).size());
+
+ // The number of commands pending on all Datanodes is 0
+ when(nodeManager.getTotalDatanodeCommandCount(any(),
+ any())).thenReturn(0);
+ assertEquals(datanodeDetails.size(),
+ service.getDatanodesWithinCommandLimit(datanodeDetails).size());
+
+ // The number of commands pending on first Datanodes has reached the limit.
+ DatanodeDetails fullDatanode = datanodeDetails.get(0);
+ when(nodeManager.getTotalDatanodeCommandCount(fullDatanode,
+ Type.deleteBlocksCommand)).thenReturn(pendingCommandLimit);
+ Set includeNodes =
+ service.getDatanodesWithinCommandLimit(datanodeDetails);
+ assertEquals(datanodeDetails.size() - 1,
+ includeNodes.size());
+ assertFalse(includeNodes.contains(fullDatanode));
+ }
+
+ private DeletedBlocksTransaction createTestDeleteTxn(
+ long txnID, List blocks, long containerID) {
+ return DeletedBlocksTransaction.newBuilder().setTxID(txnID)
+ .setContainerID(containerID).addAllLocalID(blocks).setCount(0).build();
+ }
+}
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/block/TestSCMDeleteBlocksCommandStatusManager.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/block/TestSCMDeleteBlocksCommandStatusManager.java
new file mode 100644
index 000000000000..888cb42fd7de
--- /dev/null
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/block/TestSCMDeleteBlocksCommandStatusManager.java
@@ -0,0 +1,256 @@
+/**
+ * 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.block;
+
+import org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.apache.hadoop.hdds.scm.block.SCMDeletedBlockTransactionStatusManager.SCMDeleteBlocksCommandStatusManager;
+import static org.apache.hadoop.hdds.scm.block.SCMDeletedBlockTransactionStatusManager.SCMDeleteBlocksCommandStatusManager.CmdStatus.SENT;
+import static org.apache.hadoop.hdds.scm.block.SCMDeletedBlockTransactionStatusManager.SCMDeleteBlocksCommandStatusManager.CmdStatus.TO_BE_SENT;
+import static org.apache.hadoop.hdds.scm.block.SCMDeletedBlockTransactionStatusManager.SCMDeleteBlocksCommandStatusManager.CmdStatusData;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * A test for SCMDeleteBlocksCommandStatusManager.
+ */
+public class TestSCMDeleteBlocksCommandStatusManager {
+
+ private SCMDeleteBlocksCommandStatusManager manager;
+ private UUID dnId1;
+ private UUID dnId2;
+ private long scmCmdId1;
+ private long scmCmdId2;
+ private long scmCmdId3;
+ private long scmCmdId4;
+ private Set deletedBlocksTxIds1;
+ private Set deletedBlocksTxIds2;
+ private Set deletedBlocksTxIds3;
+ private Set deletedBlocksTxIds4;
+
+ @BeforeEach
+ public void setup() throws Exception {
+ manager = new SCMDeleteBlocksCommandStatusManager();
+ // Create test data
+ dnId1 = UUID.randomUUID();
+ dnId2 = UUID.randomUUID();
+ scmCmdId1 = 1L;
+ scmCmdId2 = 2L;
+ scmCmdId3 = 3L;
+ scmCmdId4 = 4L;
+ deletedBlocksTxIds1 = new HashSet<>();
+ deletedBlocksTxIds1.add(100L);
+ deletedBlocksTxIds2 = new HashSet<>();
+ deletedBlocksTxIds2.add(200L);
+ deletedBlocksTxIds3 = new HashSet<>();
+ deletedBlocksTxIds3.add(300L);
+ deletedBlocksTxIds4 = new HashSet<>();
+ deletedBlocksTxIds4.add(400L);
+ }
+
+ @Test
+ public void testRecordScmCommand() {
+ CmdStatusData statusData =
+ SCMDeleteBlocksCommandStatusManager.createScmCmdStatusData(
+ dnId1, scmCmdId1, deletedBlocksTxIds1);
+
+ manager.recordScmCommand(statusData);
+
+ assertNotNull(manager.getScmCmdStatusRecord().get(dnId1));
+ assertEquals(1, manager.getScmCmdStatusRecord().get(dnId1).size());
+ CmdStatusData cmdStatusData =
+ manager.getScmCmdStatusRecord().get(dnId1).get(scmCmdId1);
+ assertNotNull(cmdStatusData);
+ assertEquals(dnId1, statusData.getDnId());
+ assertEquals(scmCmdId1, statusData.getScmCmdId());
+ assertEquals(deletedBlocksTxIds1, statusData.getDeletedBlocksTxIds());
+ // The default status is `CmdStatus.TO_BE_SENT`
+ assertEquals(TO_BE_SENT, statusData.getStatus());
+ }
+
+ @Test
+ public void testOnSent() {
+ CmdStatusData statusData =
+ SCMDeleteBlocksCommandStatusManager.createScmCmdStatusData(
+ dnId1, scmCmdId1, deletedBlocksTxIds1);
+ manager.recordScmCommand(statusData);
+
+ Map dnStatusRecord =
+ manager.getScmCmdStatusRecord().get(dnId1);
+ // After the Command is sent by SCM, the status of the Command
+ // will change from TO_BE_SENT to SENT
+ assertEquals(TO_BE_SENT, dnStatusRecord.get(scmCmdId1).getStatus());
+ manager.onSent(dnId1, scmCmdId1);
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId1).getStatus());
+ }
+
+ @Test
+ public void testUpdateStatusByDNCommandStatus() {
+ // Test all Status update by Datanode Heartbeat report.
+ // SENT -> PENDING_EXECUTED: The DeleteBlocksCommand is sent and received
+ // by the Datanode, but the command is not executed by the Datanode,
+ // the command is waiting to be executed.
+
+ // SENT -> NEED_RESEND: The DeleteBlocksCommand is sent and lost before
+ // it is received by the DN.
+ // SENT -> EXECUTED: The DeleteBlocksCommand has been sent to Datanode,
+ // executed by DN, and executed successfully.
+ //
+ // PENDING_EXECUTED -> PENDING_EXECUTED: The DeleteBlocksCommand continues
+ // to wait to be executed by Datanode.
+ // PENDING_EXECUTED -> NEED_RESEND: The DeleteBlocksCommand waited for a
+ // while and was executed, but the execution failed; Or the
+ // DeleteBlocksCommand was lost while waiting(such as the Datanode restart)
+ //
+ // PENDING_EXECUTED -> EXECUTED: The Command waits for a period of
+ // time on the DN and is executed successfully.
+
+ recordAndSentCommand(manager, dnId1,
+ Arrays.asList(scmCmdId1, scmCmdId2, scmCmdId3, scmCmdId4),
+ Arrays.asList(deletedBlocksTxIds1, deletedBlocksTxIds2,
+ deletedBlocksTxIds3, deletedBlocksTxIds4));
+
+ Map dnStatusRecord =
+ manager.getScmCmdStatusRecord().get(dnId1);
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId1).getStatus());
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId2).getStatus());
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId3).getStatus());
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId4).getStatus());
+
+ // SENT -> PENDING_EXECUTED
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId1,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.PENDING);
+ // SENT -> EXECUTED
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId2,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.EXECUTED);
+ // SENT -> NEED_RESEND
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId3,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.FAILED);
+ // SENT -> PENDING_EXECUTED
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId4,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.PENDING);
+
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId1).getStatus());
+ assertNull(dnStatusRecord.get(scmCmdId2));
+ assertNull(dnStatusRecord.get(scmCmdId3));
+ assertEquals(SENT, dnStatusRecord.get(scmCmdId4).getStatus());
+ }
+
+ @Test
+ public void testCleanSCMCommandForDn() {
+ // Transactions in states EXECUTED and NEED_RESEND will be cleaned up
+ // directly, while transactions in states PENDING_EXECUTED and SENT
+ // will be cleaned up after timeout
+ recordAndSentCommand(manager, dnId1,
+ Arrays.asList(scmCmdId1, scmCmdId2, scmCmdId3, scmCmdId4),
+ Arrays.asList(deletedBlocksTxIds1, deletedBlocksTxIds2,
+ deletedBlocksTxIds3, deletedBlocksTxIds4));
+
+ // SENT -> PENDING_EXECUTED
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId1,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.PENDING);
+ // SENT -> EXECUTED
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId2,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.EXECUTED);
+ // SENT -> NEED_RESEND
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId3,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.FAILED);
+
+ Map dnStatusRecord =
+ manager.getScmCmdStatusRecord().get(dnId1);
+ assertNotNull(dnStatusRecord.get(scmCmdId1));
+ assertNull(dnStatusRecord.get(scmCmdId2));
+ assertNull(dnStatusRecord.get(scmCmdId3));
+ assertNotNull(dnStatusRecord.get(scmCmdId4));
+
+ manager.cleanTimeoutSCMCommand(dnId1, Long.MAX_VALUE);
+
+ // scmCmdId1 is PENDING_EXECUTED will be cleaned up after timeout
+ assertNotNull(dnStatusRecord.get(scmCmdId1));
+ assertNull(dnStatusRecord.get(scmCmdId3));
+ assertNull(dnStatusRecord.get(scmCmdId2));
+ // scmCmdId4 is SENT will be cleaned up after timeout
+ assertNotNull(dnStatusRecord.get(scmCmdId4));
+
+ manager.cleanTimeoutSCMCommand(dnId1, -1);
+ assertNull(dnStatusRecord.get(scmCmdId1));
+ assertNull(dnStatusRecord.get(scmCmdId4));
+ }
+
+ @Test
+ public void testCleanAllTimeoutSCMCommand() {
+ // Test All EXECUTED and NEED_RESEND status in the DN will be cleaned up
+
+ // Transactions in states EXECUTED and NEED_RESEND will be cleaned up
+ // directly, while transactions in states PENDING_EXECUTED and SENT
+ // will be cleaned up after timeout
+ recordAndSentCommand(manager, dnId1, Arrays.asList(scmCmdId1),
+ Arrays.asList(deletedBlocksTxIds1));
+ recordAndSentCommand(manager, dnId2, Arrays.asList(scmCmdId2),
+ Arrays.asList(deletedBlocksTxIds2));
+
+ Map dn1StatusRecord =
+ manager.getScmCmdStatusRecord().get(dnId1);
+ Map dn2StatusRecord =
+ manager.getScmCmdStatusRecord().get(dnId2);
+
+ // Only let the scmCmdId1 have a Heartbeat report, its status will be
+ // updated, the scmCmdId2 still in SENT status.
+ // SENT -> PENDING_EXECUTED
+ manager.updateStatusByDNCommandStatus(dnId1, scmCmdId1,
+ StorageContainerDatanodeProtocolProtos.CommandStatus.Status.PENDING);
+
+ manager.cleanAllTimeoutSCMCommand(Long.MAX_VALUE);
+ // scmCmdId1 is PENDING_EXECUTED will be cleaned up after timeout
+ assertNotNull(dn1StatusRecord.get(scmCmdId1));
+ assertNotNull(dn2StatusRecord.get(scmCmdId2));
+
+ // scmCmdId2 is SENT will be cleaned up after timeout
+ manager.cleanAllTimeoutSCMCommand(-1);
+ assertNull(dn1StatusRecord.get(scmCmdId1));
+ assertNull(dn2StatusRecord.get(scmCmdId2));
+
+ }
+
+ private void recordAndSentCommand(
+ SCMDeleteBlocksCommandStatusManager statusManager,
+ UUID dnId, List scmCmdIds, List> txIds) {
+ assertEquals(scmCmdIds.size(), txIds.size());
+ for (int i = 0; i < scmCmdIds.size(); i++) {
+ long scmCmdId = scmCmdIds.get(i);
+ Set deletedBlocksTxIds = txIds.get(i);
+ CmdStatusData statusData =
+ SCMDeleteBlocksCommandStatusManager.createScmCmdStatusData(
+ dnId, scmCmdId, deletedBlocksTxIds);
+ statusManager.recordScmCommand(statusData);
+ statusManager.onSent(dnId, scmCmdId);
+ }
+ }
+
+}
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/MockNodeManager.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/MockNodeManager.java
index 98638ebe009d..794dedceef06 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/MockNodeManager.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/MockNodeManager.java
@@ -227,7 +227,7 @@ private void populateNodeMetric(DatanodeDetails datanodeDetails, int x) {
NODES[x % NODES.length].capacity - NODES[x % NODES.length].used;
newStat.set(
(NODES[x % NODES.length].capacity),
- (NODES[x % NODES.length].used), remaining);
+ (NODES[x % NODES.length].used), remaining, 0, 100000);
this.nodeMetricMap.put(datanodeDetails, newStat);
aggregateStat.add(newStat);
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestContainerBalancerTask.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestContainerBalancerTask.java
index 4bc3cf43cf6e..56d02dabb5fa 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestContainerBalancerTask.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestContainerBalancerTask.java
@@ -1207,7 +1207,8 @@ private double createCluster() {
datanodeCapacity = (long) (datanodeUsedSpace / nodeUtilizations.get(i));
}
SCMNodeStat stat = new SCMNodeStat(datanodeCapacity, datanodeUsedSpace,
- datanodeCapacity - datanodeUsedSpace);
+ datanodeCapacity - datanodeUsedSpace, 0,
+ datanodeCapacity - datanodeUsedSpace - 1);
nodesInCluster.get(i).setScmNodeStat(stat);
clusterUsedSpace += datanodeUsedSpace;
clusterCapacity += datanodeCapacity;
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestFindTargetStrategy.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestFindTargetStrategy.java
index 7e734042d883..bb6f17bcc105 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestFindTargetStrategy.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/balancer/TestFindTargetStrategy.java
@@ -56,11 +56,11 @@ public void testFindTargetGreedyByUsage() {
//create three datanodes with different usageinfo
DatanodeUsageInfo dui1 = new DatanodeUsageInfo(MockDatanodeDetails
- .randomDatanodeDetails(), new SCMNodeStat(100, 0, 40));
+ .randomDatanodeDetails(), new SCMNodeStat(100, 0, 40, 0, 30));
DatanodeUsageInfo dui2 = new DatanodeUsageInfo(MockDatanodeDetails
- .randomDatanodeDetails(), new SCMNodeStat(100, 0, 60));
+ .randomDatanodeDetails(), new SCMNodeStat(100, 0, 60, 0, 30));
DatanodeUsageInfo dui3 = new DatanodeUsageInfo(MockDatanodeDetails
- .randomDatanodeDetails(), new SCMNodeStat(100, 0, 80));
+ .randomDatanodeDetails(), new SCMNodeStat(100, 0, 80, 0, 30));
//insert in ascending order
overUtilizedDatanodes.add(dui1);
@@ -98,11 +98,11 @@ public void testFindTargetGreedyByUsage() {
public void testResetPotentialTargets() {
// create three datanodes with different usage infos
DatanodeUsageInfo dui1 = new DatanodeUsageInfo(MockDatanodeDetails
- .randomDatanodeDetails(), new SCMNodeStat(100, 30, 70));
+ .randomDatanodeDetails(), new SCMNodeStat(100, 30, 70, 0, 50));
DatanodeUsageInfo dui2 = new DatanodeUsageInfo(MockDatanodeDetails
- .randomDatanodeDetails(), new SCMNodeStat(100, 20, 80));
+ .randomDatanodeDetails(), new SCMNodeStat(100, 20, 80, 0, 60));
DatanodeUsageInfo dui3 = new DatanodeUsageInfo(MockDatanodeDetails
- .randomDatanodeDetails(), new SCMNodeStat(100, 10, 90));
+ .randomDatanodeDetails(), new SCMNodeStat(100, 10, 90, 0, 70));
List potentialTargets = new ArrayList<>();
potentialTargets.add(dui1);
@@ -179,18 +179,18 @@ public void testFindTargetGreedyByNetworkTopology() {
List overUtilizedDatanodes = new ArrayList<>();
//set the farthest target with the lowest usage info
overUtilizedDatanodes.add(
- new DatanodeUsageInfo(target5, new SCMNodeStat(100, 0, 90)));
+ new DatanodeUsageInfo(target5, new SCMNodeStat(100, 0, 90, 0, 80)));
//set the tree targets, which have the same network topology distance
//to source , with different usage info
overUtilizedDatanodes.add(
- new DatanodeUsageInfo(target2, new SCMNodeStat(100, 0, 20)));
+ new DatanodeUsageInfo(target2, new SCMNodeStat(100, 0, 20, 0, 10)));
overUtilizedDatanodes.add(
- new DatanodeUsageInfo(target3, new SCMNodeStat(100, 0, 40)));
+ new DatanodeUsageInfo(target3, new SCMNodeStat(100, 0, 40, 0, 30)));
overUtilizedDatanodes.add(
- new DatanodeUsageInfo(target4, new SCMNodeStat(100, 0, 60)));
+ new DatanodeUsageInfo(target4, new SCMNodeStat(100, 0, 60, 0, 50)));
//set the nearest target with the highest usage info
overUtilizedDatanodes.add(
- new DatanodeUsageInfo(target1, new SCMNodeStat(100, 0, 10)));
+ new DatanodeUsageInfo(target1, new SCMNodeStat(100, 0, 10, 0, 5)));
FindTargetGreedyByNetworkTopology findTargetGreedyByNetworkTopology =
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/placement/algorithms/TestSCMContainerPlacementCapacity.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/placement/algorithms/TestSCMContainerPlacementCapacity.java
index 910fe75ede6c..e51f9731ad4a 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/placement/algorithms/TestSCMContainerPlacementCapacity.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/container/placement/algorithms/TestSCMContainerPlacementCapacity.java
@@ -103,13 +103,13 @@ public void chooseDatanodes() throws SCMException {
.thenReturn(new ArrayList<>(datanodes));
when(mockNodeManager.getNodeStat(any()))
- .thenReturn(new SCMNodeMetric(100L, 0L, 100L));
+ .thenReturn(new SCMNodeMetric(100L, 0L, 100L, 0, 90));
when(mockNodeManager.getNodeStat(datanodes.get(2)))
- .thenReturn(new SCMNodeMetric(100L, 90L, 10L));
+ .thenReturn(new SCMNodeMetric(100L, 90L, 10L, 0, 9));
when(mockNodeManager.getNodeStat(datanodes.get(3)))
- .thenReturn(new SCMNodeMetric(100L, 80L, 20L));
+ .thenReturn(new SCMNodeMetric(100L, 80L, 20L, 0, 19));
when(mockNodeManager.getNodeStat(datanodes.get(4)))
- .thenReturn(new SCMNodeMetric(100L, 70L, 30L));
+ .thenReturn(new SCMNodeMetric(100L, 70L, 30L, 0, 20));
when(mockNodeManager.getNodeByUuid(any(UUID.class))).thenAnswer(
invocation -> datanodes.stream()
.filter(dn -> dn.getUuid().equals(invocation.getArgument(0)))
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/ha/TestSCMHAManagerImpl.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/ha/TestSCMHAManagerImpl.java
index b1c12cdf71c1..1ab60015efef 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/ha/TestSCMHAManagerImpl.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/ha/TestSCMHAManagerImpl.java
@@ -17,6 +17,7 @@
package org.apache.hadoop.hdds.scm.ha;
+import java.net.InetSocketAddress;
import java.nio.file.Path;
import java.time.Clock;
import java.time.ZoneOffset;
@@ -40,21 +41,31 @@
import org.apache.hadoop.hdds.security.x509.certificate.client.CertificateClient;
import org.apache.hadoop.hdds.utils.TransactionInfo;
import org.apache.hadoop.hdds.utils.db.BatchOperation;
+import org.apache.hadoop.hdds.utils.db.DBCheckpoint;
import org.apache.hadoop.hdds.utils.db.DBStore;
import org.apache.hadoop.hdds.utils.db.Table;
+import org.apache.hadoop.net.NetUtils;
import org.apache.hadoop.security.authentication.client.AuthenticationException;
import org.apache.ozone.test.GenericTestUtils;
import org.apache.ratis.server.DivisionInfo;
-import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.io.TempDir;
import java.io.IOException;
+import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
@@ -64,27 +75,35 @@
/**
* Test cases to verify {@link org.apache.hadoop.hdds.scm.ha.SCMHAManagerImpl}.
*/
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class TestSCMHAManagerImpl {
- @TempDir
+ private static final String LEADER_SCM_ID = "leader";
+ private static final int LEADER_PORT = 9894;
+ private static final String FOLLOWER_SCM_ID = "follower";
+
private Path storageBaseDir;
private String clusterID;
private SCMHAManager primarySCMHAManager;
+ private SCMRatisServer follower;
- @BeforeEach
- void setup() throws IOException, InterruptedException,
+ @BeforeAll
+ void setup(@TempDir Path tempDir) throws IOException, InterruptedException,
TimeoutException {
+ storageBaseDir = tempDir;
clusterID = UUID.randomUUID().toString();
- OzoneConfiguration conf = getConfig("scm1", 9894);
- final StorageContainerManager scm = getMockStorageContainerManager(conf);
- SCMRatisServerImpl.initialize(clusterID, scm.getScmId(),
- scm.getScmNodeDetails(), conf);
- scm.getScmHAManager().start();
+ final StorageContainerManager scm = getMockStorageContainerManager(LEADER_SCM_ID, LEADER_PORT);
+ SCMRatisServerImpl.initialize(clusterID, LEADER_SCM_ID, scm.getScmNodeDetails(), scm.getConfiguration());
primarySCMHAManager = scm.getScmHAManager();
+ primarySCMHAManager.start();
final DivisionInfo ratisDivision = primarySCMHAManager.getRatisServer()
.getDivision().getInfo();
// Wait for Ratis Server to be ready
waitForSCMToBeReady(ratisDivision);
+ StorageContainerManager followerSCM = getMockStorageContainerManager(FOLLOWER_SCM_ID, 9898);
+ follower = followerSCM.getScmHAManager()
+ .getRatisServer();
}
private OzoneConfiguration getConfig(String scmId, int ratisPort) {
@@ -97,42 +116,61 @@ private OzoneConfiguration getConfig(String scmId, int ratisPort) {
return conf;
}
- public void waitForSCMToBeReady(DivisionInfo ratisDivision)
+ private void waitForSCMToBeReady(DivisionInfo ratisDivision)
throws TimeoutException,
InterruptedException {
GenericTestUtils.waitFor(ratisDivision::isLeaderReady,
1000, 10000);
}
- @AfterEach
- public void cleanup() throws IOException {
+ @AfterAll
+ void cleanup() throws IOException {
+ follower.stop();
primarySCMHAManager.stop();
}
@Test
- public void testAddSCM() throws IOException, InterruptedException {
- Assertions.assertEquals(1, primarySCMHAManager.getRatisServer()
- .getDivision().getGroup().getPeers().size());
+ @Order(1)
+ void testAddSCM() throws IOException {
+ Assertions.assertEquals(1, getPeerCount());
- final StorageContainerManager scm2 = getMockStorageContainerManager(
- getConfig("scm2", 9898));
- try {
- scm2.getScmHAManager().getRatisServer().start();
- final AddSCMRequest request = new AddSCMRequest(
- clusterID, scm2.getScmId(),
- "localhost:" + scm2.getScmHAManager().getRatisServer()
- .getDivision().getRaftServer().getServerRpc()
- .getInetSocketAddress().getPort());
- primarySCMHAManager.addSCM(request);
- Assertions.assertEquals(2, primarySCMHAManager.getRatisServer()
- .getDivision().getGroup().getPeers().size());
- } finally {
- scm2.getScmHAManager().getRatisServer().stop();
- }
+ follower.start();
+ final AddSCMRequest request = new AddSCMRequest(
+ clusterID, FOLLOWER_SCM_ID, getFollowerAddress());
+ primarySCMHAManager.addSCM(request);
+ Assertions.assertEquals(2, getPeerCount());
}
@Test
- public void testHARingRemovalErrors() throws IOException,
+ @Order(2) // requires testAddSCM
+ void testRemoveSCM() throws IOException {
+ assumeThat(getPeerCount()).isEqualTo(2);
+
+ final RemoveSCMRequest removeSCMRequest = new RemoveSCMRequest(
+ clusterID, FOLLOWER_SCM_ID, getFollowerAddress());
+ primarySCMHAManager.removeSCM(removeSCMRequest);
+ assertEquals(1, getPeerCount());
+ }
+
+ private int getPeerCount() {
+ return primarySCMHAManager.getRatisServer()
+ .getDivision().getGroup().getPeers().size();
+ }
+
+ private String getRaftServerAddress(SCMRatisServer ratisServer) {
+ return "localhost:" + ratisServer.getDivision()
+ .getRaftServer()
+ .getServerRpc()
+ .getInetSocketAddress()
+ .getPort();
+ }
+
+ private String getFollowerAddress() {
+ return getRaftServerAddress(follower);
+ }
+
+ @Test
+ void testHARingRemovalErrors() throws IOException,
AuthenticationException {
OzoneConfiguration config = new OzoneConfiguration();
config.set(ScmConfigKeys.OZONE_SCM_PRIMORDIAL_NODE_ID_KEY, "scm1");
@@ -160,39 +198,9 @@ public void testHARingRemovalErrors() throws IOException,
scm2.getScmHAManager().getRatisServer().stop();
}
}
- @Test
- public void testRemoveSCM() throws IOException, InterruptedException {
- Assertions.assertEquals(1, primarySCMHAManager.getRatisServer()
- .getDivision().getGroup().getPeers().size());
-
- final StorageContainerManager scm2 = getMockStorageContainerManager(
- getConfig("scm2", 9898));
- try {
- scm2.getScmHAManager().getRatisServer().start();
- final AddSCMRequest addSCMRequest = new AddSCMRequest(
- clusterID, scm2.getScmId(),
- "localhost:" + scm2.getScmHAManager().getRatisServer()
- .getDivision().getRaftServer().getServerRpc()
- .getInetSocketAddress().getPort());
- primarySCMHAManager.addSCM(addSCMRequest);
- Assertions.assertEquals(2, primarySCMHAManager.getRatisServer()
- .getDivision().getGroup().getPeers().size());
-
- final RemoveSCMRequest removeSCMRequest = new RemoveSCMRequest(
- clusterID, scm2.getScmId(), "localhost:" +
- scm2.getScmHAManager().getRatisServer().getDivision()
- .getRaftServer().getServerRpc().getInetSocketAddress().getPort());
- primarySCMHAManager.removeSCM(removeSCMRequest);
- Assertions.assertEquals(1, primarySCMHAManager.getRatisServer()
- .getDivision().getGroup().getPeers().size());
- } finally {
- scm2.getScmHAManager().getRatisServer().stop();
- }
- }
- private StorageContainerManager getMockStorageContainerManager(
- OzoneConfiguration conf) throws IOException {
- final String scmID = UUID.randomUUID().toString();
+ private StorageContainerManager getMockStorageContainerManager(String scmID, int port) throws IOException {
+ OzoneConfiguration conf = getConfig(scmID, port);
final DBStore dbStore = mock(DBStore.class);
final SCMContext scmContext = mock(SCMContext.class);
@@ -217,6 +225,7 @@ private StorageContainerManager getMockStorageContainerManager(
mock(SCMDatanodeProtocolServer.class);
when(scm.getClusterId()).thenReturn(clusterID);
+ when(scm.getConfiguration()).thenReturn(conf);
when(scm.getScmId()).thenReturn(scmID);
when(scm.getScmMetadataStore()).thenReturn(metadataStore);
when(scm.getScmNodeDetails()).thenReturn(nodeDetails);
@@ -235,12 +244,33 @@ private StorageContainerManager getMockStorageContainerManager(
when(scmHANodeDetails.getLocalNodeDetails()).thenReturn(nodeDetails);
when(blockManager.getDeletedBlockLog()).thenReturn(deletedBlockLog);
when(dbStore.initBatchOperation()).thenReturn(batchOperation);
- when(nodeDetails.getRatisHostPortStr()).thenReturn("localhost:" +
- conf.get(ScmConfigKeys.OZONE_SCM_RATIS_PORT_KEY));
+ when(nodeDetails.getRatisHostPortStr()).thenReturn("localhost:" + port);
when(scm.getSystemClock()).thenReturn(Clock.system(ZoneOffset.UTC));
+ if (FOLLOWER_SCM_ID.equals(scmID)) {
+ final SCMNodeDetails leaderNodeDetails = mock(SCMNodeDetails.class);
+ final List peerNodeDetails = singletonList(leaderNodeDetails);
+ when(scmHANodeDetails.getPeerNodeDetails()).thenReturn(peerNodeDetails);
+ when(leaderNodeDetails.getNodeId()).thenReturn(LEADER_SCM_ID);
+ when(leaderNodeDetails.getGrpcPort()).thenReturn(LEADER_PORT);
+ when(leaderNodeDetails.getRatisHostPortStr()).thenReturn("localhost:" + LEADER_PORT);
+ InetSocketAddress rpcAddress = NetUtils.createSocketAddr("localhost", LEADER_PORT);
+ when(leaderNodeDetails.getRpcAddress()).thenReturn(rpcAddress);
+ when(leaderNodeDetails.getInetAddress()).thenReturn(rpcAddress.getAddress());
+ }
+
+ DBCheckpoint checkpoint = mock(DBCheckpoint.class);
+ SCMSnapshotProvider scmSnapshotProvider = mock(SCMSnapshotProvider.class);
+ when(scmSnapshotProvider.getSCMDBSnapshot(LEADER_SCM_ID))
+ .thenReturn(checkpoint);
+
final SCMHAManager manager = new SCMHAManagerImpl(conf,
- new SecurityConfig(conf), scm);
+ new SecurityConfig(conf), scm) {
+ @Override
+ protected SCMSnapshotProvider newScmSnapshotProvider(StorageContainerManager storageContainerManager) {
+ return scmSnapshotProvider;
+ }
+ };
when(scm.getScmHAManager()).thenReturn(manager);
return scm;
}
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestDeadNodeHandler.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestDeadNodeHandler.java
index 168fdd11a57b..0f65cdb10870 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestDeadNodeHandler.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestDeadNodeHandler.java
@@ -47,6 +47,7 @@
.StorageContainerDatanodeProtocolProtos.StorageReportProto;
import org.apache.hadoop.hdds.scm.ScmConfigKeys;
import org.apache.hadoop.hdds.scm.HddsTestUtils;
+import org.apache.hadoop.hdds.scm.block.DeletedBlockLog;
import org.apache.hadoop.hdds.scm.container.ContainerID;
import org.apache.hadoop.hdds.scm.container.ContainerManager;
import org.apache.hadoop.hdds.scm.container.ContainerNotFoundException;
@@ -90,6 +91,7 @@ public class TestDeadNodeHandler {
private EventQueue eventQueue;
private String storageDir;
private SCMContext scmContext;
+ private DeletedBlockLog deletedBlockLog;
@BeforeEach
public void setup() throws IOException, AuthenticationException {
@@ -117,8 +119,9 @@ public void setup() throws IOException, AuthenticationException {
pipelineManager.setPipelineProvider(RATIS,
mockRatisProvider);
containerManager = scm.getContainerManager();
+ deletedBlockLog = Mockito.mock(DeletedBlockLog.class);
deadNodeHandler = new DeadNodeHandler(nodeManager,
- Mockito.mock(PipelineManager.class), containerManager);
+ Mockito.mock(PipelineManager.class), containerManager, deletedBlockLog);
healthyReadOnlyNodeHandler =
new HealthyReadOnlyNodeHandler(nodeManager,
pipelineManager);
@@ -134,6 +137,7 @@ public void teardown() {
}
@Test
+ @SuppressWarnings("checkstyle:MethodLength")
public void testOnMessage() throws Exception {
//GIVEN
DatanodeDetails datanode1 = MockDatanodeDetails.randomDatanodeDetails();
@@ -233,6 +237,9 @@ public void testOnMessage() throws Exception {
Assertions.assertFalse(
nodeManager.getClusterNetworkTopologyMap().contains(datanode1));
+ Mockito.verify(deletedBlockLog, Mockito.times(0))
+ .onDatanodeDead(datanode1.getUuid());
+
Set container1Replicas = containerManager
.getContainerReplicas(ContainerID.valueOf(container1.getContainerID()));
Assertions.assertEquals(2, container1Replicas.size());
@@ -260,6 +267,9 @@ public void testOnMessage() throws Exception {
Assertions.assertEquals(0,
nodeManager.getCommandQueueCount(datanode1.getUuid(), cmd.getType()));
+ Mockito.verify(deletedBlockLog, Mockito.times(1))
+ .onDatanodeDead(datanode1.getUuid());
+
container1Replicas = containerManager
.getContainerReplicas(ContainerID.valueOf(container1.getContainerID()));
Assertions.assertEquals(1, container1Replicas.size());
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestSCMNodeManager.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestSCMNodeManager.java
index e3da551c3edc..a3decb0efb54 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestSCMNodeManager.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/node/TestSCMNodeManager.java
@@ -954,16 +954,17 @@ scmStorageConfig, eventPublisher, new NetworkTopologyImpl(conf),
@Test
public void testProcessCommandQueueReport()
- throws IOException, NodeNotFoundException {
+ throws IOException, NodeNotFoundException, AuthenticationException {
OzoneConfiguration conf = new OzoneConfiguration();
SCMStorageConfig scmStorageConfig = mock(SCMStorageConfig.class);
when(scmStorageConfig.getClusterID()).thenReturn("xyz111");
EventPublisher eventPublisher = mock(EventPublisher.class);
HDDSLayoutVersionManager lvm =
new HDDSLayoutVersionManager(scmStorageConfig.getLayoutVersion());
+ createNodeManager(getConf());
SCMNodeManager nodeManager = new SCMNodeManager(conf,
scmStorageConfig, eventPublisher, new NetworkTopologyImpl(conf),
- SCMContext.emptyContext(), lvm);
+ scmContext, lvm);
LayoutVersionProto layoutInfo = toLayoutVersionProto(
lvm.getMetadataLayoutVersion(), lvm.getSoftwareLayoutVersion());
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/TestWritableRatisContainerProvider.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/TestWritableRatisContainerProvider.java
new file mode 100644
index 000000000000..d5d9208adae4
--- /dev/null
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/hdds/scm/pipeline/TestWritableRatisContainerProvider.java
@@ -0,0 +1,179 @@
+/*
+ * 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.pipeline;
+
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
+import org.apache.hadoop.hdds.client.ReplicationConfig;
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
+import org.apache.hadoop.hdds.scm.PipelineChoosePolicy;
+import org.apache.hadoop.hdds.scm.container.ContainerInfo;
+import org.apache.hadoop.hdds.scm.container.ContainerManager;
+import org.apache.hadoop.hdds.scm.container.common.helpers.ExcludeList;
+import org.apache.hadoop.hdds.scm.exceptions.SCMException;
+import org.apache.hadoop.hdds.scm.pipeline.choose.algorithms.RandomPipelineChoosePolicy;
+import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singletonList;
+import static org.apache.hadoop.hdds.scm.pipeline.Pipeline.PipelineState.OPEN;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+class TestWritableRatisContainerProvider {
+
+ private static final ReplicationConfig REPLICATION_CONFIG =
+ RatisReplicationConfig.getInstance(HddsProtos.ReplicationFactor.THREE);
+ private static final String OWNER = "owner";
+ private static final int CONTAINER_SIZE = 1234;
+ private static final ExcludeList NO_EXCLUSION = new ExcludeList();
+
+ private final OzoneConfiguration conf = new OzoneConfiguration();
+ private final PipelineChoosePolicy policy = new RandomPipelineChoosePolicy();
+ private final AtomicLong containerID = new AtomicLong(1);
+
+ @Mock
+ private PipelineManager pipelineManager;
+
+ @Mock
+ private ContainerManager containerManager;
+
+ @Test
+ void returnsExistingContainer() throws Exception {
+ Pipeline pipeline = MockPipeline.createPipeline(3);
+ ContainerInfo existingContainer = pipelineHasContainer(pipeline);
+
+ existingPipelines(pipeline);
+
+ ContainerInfo container = createSubject().getContainer(CONTAINER_SIZE, REPLICATION_CONFIG, OWNER, NO_EXCLUSION);
+
+ assertSame(existingContainer, container);
+ verifyPipelineNotCreated();
+ }
+
+ @RepeatedTest(100)
+ void skipsPipelineWithoutContainer() throws Exception {
+ Pipeline pipeline = MockPipeline.createPipeline(3);
+ ContainerInfo existingContainer = pipelineHasContainer(pipeline);
+
+ Pipeline pipelineWithoutContainer = MockPipeline.createPipeline(3);
+ existingPipelines(pipelineWithoutContainer, pipeline);
+
+ ContainerInfo container = createSubject().getContainer(CONTAINER_SIZE, REPLICATION_CONFIG, OWNER, NO_EXCLUSION);
+
+ assertSame(existingContainer, container);
+ verifyPipelineNotCreated();
+ }
+
+ @Test
+ void createsNewContainerIfNoneFound() throws Exception {
+ ContainerInfo newContainer = createNewContainerOnDemand();
+
+ ContainerInfo container = createSubject().getContainer(CONTAINER_SIZE, REPLICATION_CONFIG, OWNER, NO_EXCLUSION);
+
+ assertSame(newContainer, container);
+ verifyPipelineCreated();
+ }
+
+ @Test
+ void failsIfContainerCannotBeCreated() throws Exception {
+ throwWhenCreatePipeline();
+
+ assertThrows(IOException.class,
+ () -> createSubject().getContainer(CONTAINER_SIZE, REPLICATION_CONFIG, OWNER, NO_EXCLUSION));
+
+ verifyPipelineCreated();
+ }
+
+ private void existingPipelines(Pipeline... pipelines) {
+ existingPipelines(new ArrayList<>(asList(pipelines)));
+ }
+
+ private void existingPipelines(List pipelines) {
+ when(pipelineManager.getPipelines(REPLICATION_CONFIG, OPEN, emptySet(), emptySet()))
+ .thenReturn(pipelines);
+ }
+
+ private ContainerInfo pipelineHasContainer(Pipeline pipeline) {
+ ContainerInfo container = new ContainerInfo.Builder()
+ .setContainerID(containerID.getAndIncrement())
+ .setPipelineID(pipeline.getId())
+ .build();
+
+ when(containerManager.getMatchingContainer(CONTAINER_SIZE, OWNER, pipeline, emptySet()))
+ .thenReturn(container);
+
+ return container;
+ }
+
+ private ContainerInfo createNewContainerOnDemand() throws IOException {
+ Pipeline newPipeline = MockPipeline.createPipeline(3);
+ when(pipelineManager.createPipeline(REPLICATION_CONFIG))
+ .thenReturn(newPipeline);
+
+ when(pipelineManager.getPipelines(REPLICATION_CONFIG, OPEN, emptySet(), emptySet()))
+ .thenReturn(emptyList())
+ .thenReturn(new ArrayList<>(singletonList(newPipeline)));
+
+ return pipelineHasContainer(newPipeline);
+ }
+
+ private void throwWhenCreatePipeline() throws IOException {
+ when(pipelineManager.createPipeline(REPLICATION_CONFIG))
+ .thenThrow(new SCMException(SCMException.ResultCodes.FAILED_TO_FIND_SUITABLE_NODE));
+ }
+
+ private WritableRatisContainerProvider createSubject() {
+ return new WritableRatisContainerProvider(conf,
+ pipelineManager, containerManager, policy);
+ }
+
+ private void verifyPipelineCreated() throws IOException {
+ verify(pipelineManager, times(2))
+ .getPipelines(REPLICATION_CONFIG, OPEN, emptySet(), emptySet());
+ verify(pipelineManager)
+ .createPipeline(REPLICATION_CONFIG);
+ }
+
+ private void verifyPipelineNotCreated() throws IOException {
+ verify(pipelineManager, times(1))
+ .getPipelines(REPLICATION_CONFIG, OPEN, emptySet(), emptySet());
+ verify(pipelineManager, never())
+ .createPipeline(REPLICATION_CONFIG);
+ }
+
+}
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/placement/TestDatanodeMetrics.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/placement/TestDatanodeMetrics.java
index 6ba2fc440a4f..9c9bfad582f7 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/placement/TestDatanodeMetrics.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/placement/TestDatanodeMetrics.java
@@ -31,13 +31,13 @@
public class TestDatanodeMetrics {
@Test
public void testSCMNodeMetric() {
- SCMNodeStat stat = new SCMNodeStat(100L, 10L, 90L);
+ SCMNodeStat stat = new SCMNodeStat(100L, 10L, 90L, 0, 80);
assertEquals((long) stat.getCapacity().get(), 100L);
assertEquals(10L, (long) stat.getScmUsed().get());
assertEquals(90L, (long) stat.getRemaining().get());
SCMNodeMetric metric = new SCMNodeMetric(stat);
- SCMNodeStat newStat = new SCMNodeStat(100L, 10L, 90L);
+ SCMNodeStat newStat = new SCMNodeStat(100L, 10L, 90L, 0, 80);
assertEquals(100L, (long) stat.getCapacity().get());
assertEquals(10L, (long) stat.getScmUsed().get());
assertEquals(90L, (long) stat.getRemaining().get());
@@ -53,8 +53,8 @@ public void testSCMNodeMetric() {
assertTrue(metric.isGreater(zeroMetric.get()));
// Another case when nodes have similar weight
- SCMNodeStat stat1 = new SCMNodeStat(10000000L, 50L, 9999950L);
- SCMNodeStat stat2 = new SCMNodeStat(10000000L, 51L, 9999949L);
+ SCMNodeStat stat1 = new SCMNodeStat(10000000L, 50L, 9999950L, 0, 100000);
+ SCMNodeStat stat2 = new SCMNodeStat(10000000L, 51L, 9999949L, 0, 100000);
assertTrue(new SCMNodeMetric(stat2).isGreater(stat1));
}
}
diff --git a/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/datanode/UsageInfoSubcommand.java b/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/datanode/UsageInfoSubcommand.java
index d46513b24bbd..b967fa0658c0 100644
--- a/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/datanode/UsageInfoSubcommand.java
+++ b/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/datanode/UsageInfoSubcommand.java
@@ -155,8 +155,16 @@ private void printInfo(DatanodeUsage info) {
+ " B", StringUtils.byteDesc(info.getRemaining()));
System.out.printf("%-13s: %s %n", "Remaining %",
PERCENT_FORMAT.format(info.getRemainingRatio()));
- System.out.printf("%-13s: %d %n%n", "Container(s)",
+ System.out.printf("%-13s: %d %n", "Container(s)",
info.getContainerCount());
+ System.out.printf("%-24s: %s (%s) %n", "Container Pre-allocated",
+ info.getCommitted() + " B", StringUtils.byteDesc(info.getCommitted()));
+ System.out.printf("%-24s: %s (%s) %n", "Remaining Allocatable",
+ (info.getRemaining() - info.getCommitted()) + " B",
+ StringUtils.byteDesc((info.getRemaining() - info.getCommitted())));
+ System.out.printf("%-24s: %s (%s) %n%n", "Free Space To Spare",
+ info.getFreeSpaceToSpare() + " B",
+ StringUtils.byteDesc(info.getFreeSpaceToSpare()));
}
/**
@@ -181,6 +189,8 @@ private static class DatanodeUsage {
private long capacity = 0;
private long used = 0;
private long remaining = 0;
+ private long committed = 0;
+ private long freeSpaceToSpare = 0;
private long containerCount = 0;
DatanodeUsage(HddsProtos.DatanodeUsageInfoProto proto) {
@@ -196,9 +206,15 @@ private static class DatanodeUsage {
if (proto.hasRemaining()) {
remaining = proto.getRemaining();
}
+ if (proto.hasCommitted()) {
+ committed = proto.getCommitted();
+ }
if (proto.hasContainerCount()) {
containerCount = proto.getContainerCount();
}
+ if (proto.hasFreeSpaceToSpare()) {
+ freeSpaceToSpare = proto.getFreeSpaceToSpare();
+ }
}
public DatanodeDetails getDatanodeDetails() {
@@ -220,6 +236,12 @@ public long getOzoneUsed() {
public long getRemaining() {
return remaining;
}
+ public long getCommitted() {
+ return committed;
+ }
+ public long getFreeSpaceToSpare() {
+ return freeSpaceToSpare;
+ }
public long getContainerCount() {
return containerCount;
diff --git a/hadoop-hdds/tools/src/test/java/org/apache/hadoop/hdds/scm/cli/datanode/TestUsageInfoSubcommand.java b/hadoop-hdds/tools/src/test/java/org/apache/hadoop/hdds/scm/cli/datanode/TestUsageInfoSubcommand.java
index 0cc8ed9be639..a52a0a7ed8f5 100644
--- a/hadoop-hdds/tools/src/test/java/org/apache/hadoop/hdds/scm/cli/datanode/TestUsageInfoSubcommand.java
+++ b/hadoop-hdds/tools/src/test/java/org/apache/hadoop/hdds/scm/cli/datanode/TestUsageInfoSubcommand.java
@@ -19,6 +19,7 @@
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.codec.CharEncoding;
import org.apache.hadoop.hdds.protocol.MockDatanodeDetails;
import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
import org.apache.hadoop.hdds.scm.client.ScmClient;
@@ -97,6 +98,38 @@ public void testCorrectJsonValuesInReport() throws IOException {
json.get(0).get("containerCount").longValue());
}
+ @Test
+ public void testOutputDataFieldsAligning() throws IOException {
+ // given
+ ScmClient scmClient = mock(ScmClient.class);
+ Mockito.when(scmClient.getDatanodeUsageInfo(
+ Mockito.anyBoolean(), Mockito.anyInt()))
+ .thenAnswer(invocation -> getUsageProto());
+
+ CommandLine c = new CommandLine(cmd);
+ c.parseArgs("-m");
+
+ // when
+ cmd.execute(scmClient);
+
+ // then
+ String output = outContent.toString(CharEncoding.UTF_8);
+ Assertions.assertTrue(output.contains("UUID :"));
+ Assertions.assertTrue(output.contains("IP Address :"));
+ Assertions.assertTrue(output.contains("Hostname :"));
+ Assertions.assertTrue(output.contains("Capacity :"));
+ Assertions.assertTrue(output.contains("Total Used :"));
+ Assertions.assertTrue(output.contains("Total Used % :"));
+ Assertions.assertTrue(output.contains("Ozone Used :"));
+ Assertions.assertTrue(output.contains("Ozone Used % :"));
+ Assertions.assertTrue(output.contains("Remaining :"));
+ Assertions.assertTrue(output.contains("Remaining % :"));
+ Assertions.assertTrue(output.contains("Container(s) :"));
+ Assertions.assertTrue(output.contains("Container Pre-allocated :"));
+ Assertions.assertTrue(output.contains("Remaining Allocatable :"));
+ Assertions.assertTrue(output.contains("Free Space To Spare :"));
+ }
+
private List getUsageProto() {
List result = new ArrayList<>();
result.add(HddsProtos.DatanodeUsageInfoProto.newBuilder()
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ECFileChecksumHelper.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ECFileChecksumHelper.java
index 3da23688418f..13ba57169878 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ECFileChecksumHelper.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ECFileChecksumHelper.java
@@ -186,13 +186,10 @@ private List getChunkInfos(OmKeyLocationInfo
LOG.debug("Initializing BlockInputStream for get key to access {}",
blockID.getContainerID());
}
- xceiverClientSpi =
- getXceiverClientFactory().acquireClientForReadData(pipeline);
+ xceiverClientSpi = getXceiverClientFactory().acquireClientForReadData(pipeline);
- ContainerProtos.DatanodeBlockID datanodeBlockID = blockID
- .getDatanodeBlockIDProtobuf();
ContainerProtos.GetBlockResponseProto response = ContainerProtocolCalls
- .getBlock(xceiverClientSpi, datanodeBlockID, token);
+ .getBlock(xceiverClientSpi, blockID, token, pipeline.getReplicaIndexes());
chunks = response.getBlockData().getChunksList();
} finally {
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ReplicatedFileChecksumHelper.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ReplicatedFileChecksumHelper.java
index 09f9c7d037e9..016121ce1a9b 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ReplicatedFileChecksumHelper.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/checksum/ReplicatedFileChecksumHelper.java
@@ -149,13 +149,9 @@ protected List getChunkInfos(
LOG.debug("Initializing BlockInputStream for get key to access {}",
blockID.getContainerID());
}
- xceiverClientSpi =
- getXceiverClientFactory().acquireClientForReadData(pipeline);
-
- ContainerProtos.DatanodeBlockID datanodeBlockID = blockID
- .getDatanodeBlockIDProtobuf();
+ xceiverClientSpi = getXceiverClientFactory().acquireClientForReadData(pipeline);
ContainerProtos.GetBlockResponseProto response = ContainerProtocolCalls
- .getBlock(xceiverClientSpi, datanodeBlockID, token);
+ .getBlock(xceiverClientSpi, blockID, token, pipeline.getReplicaIndexes());
chunks = response.getBlockData().getChunksList();
} finally {
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/ECBlockOutputStreamEntry.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/ECBlockOutputStreamEntry.java
index 241754a57f19..2cf2ab0cf9c2 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/ECBlockOutputStreamEntry.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/ECBlockOutputStreamEntry.java
@@ -37,7 +37,6 @@
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -248,8 +247,7 @@ Collection getFailedServers() {
@VisibleForTesting
Pipeline createSingleECBlockPipeline(Pipeline ecPipeline,
DatanodeDetails node, int replicaIndex) {
- Map indiciesForSinglePipeline = new HashMap<>();
- indiciesForSinglePipeline.put(node, replicaIndex);
+ Map indiciesForSinglePipeline = Collections.singletonMap(node, replicaIndex);
return Pipeline.newBuilder()
.setId(ecPipeline.getId())
.setReplicationConfig(ecPipeline.getReplicationConfig())
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/KeyInputStream.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/KeyInputStream.java
index 4843c1c45e6c..76fa1e394f6c 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/KeyInputStream.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/io/KeyInputStream.java
@@ -25,6 +25,7 @@
import java.util.stream.Collectors;
import org.apache.hadoop.hdds.client.BlockID;
+import org.apache.hadoop.hdds.scm.OzoneClientConfig;
import org.apache.hadoop.hdds.scm.XceiverClientFactory;
import org.apache.hadoop.hdds.scm.storage.BlockExtendedInputStream;
import org.apache.hadoop.hdds.scm.storage.BlockLocationInfo;
@@ -58,9 +59,9 @@ private static List createStreams(
OmKeyInfo keyInfo,
List blockInfos,
XceiverClientFactory xceiverClientFactory,
- boolean verifyChecksum,
Function retryFunction,
- BlockInputStreamFactory blockStreamFactory) {
+ BlockInputStreamFactory blockStreamFactory,
+ OzoneClientConfig config) throws IOException {
List partStreams = new ArrayList<>();
for (OmKeyLocationInfo omKeyLocationInfo : blockInfos) {
if (LOG.isDebugEnabled()) {
@@ -91,9 +92,9 @@ private static List createStreams(
omKeyLocationInfo,
omKeyLocationInfo.getPipeline(),
omKeyLocationInfo.getToken(),
- verifyChecksum,
xceiverClientFactory,
- retry);
+ retry,
+ config);
partStreams.add(stream);
}
return partStreams;
@@ -117,13 +118,13 @@ private static BlockLocationInfo getBlockLocationInfo(OmKeyInfo newKeyInfo,
private static LengthInputStream getFromOmKeyInfo(
OmKeyInfo keyInfo,
XceiverClientFactory xceiverClientFactory,
- boolean verifyChecksum,
Function retryFunction,
BlockInputStreamFactory blockStreamFactory,
- List locationInfos) {
+ List locationInfos,
+ OzoneClientConfig config) throws IOException {
List streams = createStreams(keyInfo,
- locationInfos, xceiverClientFactory, verifyChecksum, retryFunction,
- blockStreamFactory);
+ locationInfos, xceiverClientFactory, retryFunction,
+ blockStreamFactory, config);
KeyInputStream keyInputStream =
new KeyInputStream(keyInfo.getKeyName(), streams);
return new LengthInputStream(keyInputStream, keyInputStream.getLength());
@@ -134,20 +135,22 @@ private static LengthInputStream getFromOmKeyInfo(
*/
public static LengthInputStream getFromOmKeyInfo(OmKeyInfo keyInfo,
XceiverClientFactory xceiverClientFactory,
- boolean verifyChecksum, Function retryFunction,
- BlockInputStreamFactory blockStreamFactory) {
+ Function retryFunction,
+ BlockInputStreamFactory blockStreamFactory,
+ OzoneClientConfig config) throws IOException {
List keyLocationInfos = keyInfo
.getLatestVersionLocations().getBlocksLatestVersionOnly();
- return getFromOmKeyInfo(keyInfo, xceiverClientFactory, verifyChecksum,
- retryFunction, blockStreamFactory, keyLocationInfos);
+ return getFromOmKeyInfo(keyInfo, xceiverClientFactory,
+ retryFunction, blockStreamFactory, keyLocationInfos, config);
}
public static List getStreamsFromKeyInfo(OmKeyInfo keyInfo,
- XceiverClientFactory xceiverClientFactory, boolean verifyChecksum,
+ XceiverClientFactory xceiverClientFactory,
Function retryFunction,
- BlockInputStreamFactory blockStreamFactory) {
+ BlockInputStreamFactory blockStreamFactory,
+ OzoneClientConfig config) throws IOException {
List keyLocationInfos = keyInfo
.getLatestVersionLocations().getBlocksLatestVersionOnly();
@@ -162,7 +165,8 @@ public static List getStreamsFromKeyInfo(OmKeyInfo keyInfo,
// Create a KeyInputStream for each part.
for (List locationInfo : partsToBlocksMap.values()) {
lengthInputStreams.add(getFromOmKeyInfo(keyInfo, xceiverClientFactory,
- verifyChecksum, retryFunction, blockStreamFactory, locationInfo));
+ retryFunction, blockStreamFactory, locationInfo,
+ config));
}
return lengthInputStreams;
}
diff --git a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java
index 8d61f8ef8609..222823c454a7 100644
--- a/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java
+++ b/hadoop-ozone/client/src/main/java/org/apache/hadoop/ozone/client/rpc/RpcClient.java
@@ -50,6 +50,7 @@
import org.apache.hadoop.hdds.scm.XceiverClientFactory;
import org.apache.hadoop.hdds.scm.XceiverClientManager;
import org.apache.hadoop.hdds.scm.client.ClientTrustManager;
+import org.apache.hadoop.hdds.scm.storage.ByteBufferStreamOutput;
import org.apache.hadoop.hdds.security.x509.certificate.client.CACertificateProvider;
import org.apache.hadoop.hdds.scm.client.HddsClientUtils;
import org.apache.hadoop.hdds.scm.pipeline.Pipeline;
@@ -1834,11 +1835,16 @@ public OzoneOutputStream createMultipartKey(
long size, int partNumber, String uploadID) throws IOException {
final OpenKeySession openKey = newMultipartOpenKey(
volumeName, bucketName, keyName, size, partNumber, uploadID, false);
+ return createMultipartOutputStream(openKey, uploadID, partNumber);
+ }
+
+ private OzoneOutputStream createMultipartOutputStream(
+ OpenKeySession openKey, String uploadID, int partNumber
+ ) throws IOException {
KeyOutputStream keyOutputStream = createKeyOutputStream(openKey)
.setMultipartNumber(partNumber)
.setMultipartUploadID(uploadID)
.setIsMultipartKey(true)
- .setAtomicKeyCreation(isS3GRequest.get())
.build();
return createOutputStream(openKey, keyOutputStream);
}
@@ -1854,29 +1860,25 @@ public OzoneDataStreamOutput createMultipartStreamKey(
throws IOException {
final OpenKeySession openKey = newMultipartOpenKey(
volumeName, bucketName, keyName, size, partNumber, uploadID, true);
- // Amazon S3 never adds partial objects, So for S3 requests we need to
- // set atomicKeyCreation to true
- // refer: https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
- KeyDataStreamOutput keyOutputStream =
- new KeyDataStreamOutput.Builder()
- .setHandler(openKey)
- .setXceiverClientManager(xceiverClientManager)
- .setOmClient(ozoneManagerClient)
- .setReplicationConfig(openKey.getKeyInfo().getReplicationConfig())
- .setMultipartNumber(partNumber)
- .setMultipartUploadID(uploadID)
- .setIsMultipartKey(true)
- .enableUnsafeByteBufferConversion(unsafeByteBufferConversion)
- .setConfig(clientConfig)
- .setAtomicKeyCreation(isS3GRequest.get())
- .build();
- keyOutputStream
- .addPreallocateBlocks(
- openKey.getKeyInfo().getLatestVersionLocations(),
- openKey.getOpenVersion());
- final OzoneOutputStream out = createSecureOutputStream(
- openKey, keyOutputStream, null);
- return new OzoneDataStreamOutput(out != null ? out : keyOutputStream);
+ final ByteBufferStreamOutput out;
+ ReplicationConfig replicationConfig = openKey.getKeyInfo().getReplicationConfig();
+ if (replicationConfig.getReplicationType() == HddsProtos.ReplicationType.RATIS) {
+ KeyDataStreamOutput keyOutputStream = newKeyOutputStreamBuilder()
+ .setHandler(openKey)
+ .setReplicationConfig(replicationConfig)
+ .setMultipartNumber(partNumber)
+ .setMultipartUploadID(uploadID)
+ .setIsMultipartKey(true)
+ .build();
+ keyOutputStream.addPreallocateBlocks(
+ openKey.getKeyInfo().getLatestVersionLocations(),
+ openKey.getOpenVersion());
+ final OzoneOutputStream secureOut = createSecureOutputStream(openKey, keyOutputStream, null);
+ out = secureOut != null ? secureOut : keyOutputStream;
+ } else {
+ out = createMultipartOutputStream(openKey, uploadID, partNumber);
+ }
+ return new OzoneDataStreamOutput(out);
}
@Override
@@ -2221,9 +2223,8 @@ private OzoneInputStream createInputStream(
if (feInfo == null) {
LengthInputStream lengthInputStream = KeyInputStream
- .getFromOmKeyInfo(keyInfo, xceiverClientManager,
- clientConfig.isChecksumVerify(), retryFunction,
- blockInputStreamFactory);
+ .getFromOmKeyInfo(keyInfo, xceiverClientManager, retryFunction,
+ blockInputStreamFactory, clientConfig);
try {
final GDPRSymmetricKey gk = getGDPRSymmetricKey(
keyInfo.getMetadata(), Cipher.DECRYPT_MODE);
@@ -2238,9 +2239,8 @@ private OzoneInputStream createInputStream(
} else if (!keyInfo.getLatestVersionLocations().isMultipartKey()) {
// Regular Key with FileEncryptionInfo
LengthInputStream lengthInputStream = KeyInputStream
- .getFromOmKeyInfo(keyInfo, xceiverClientManager,
- clientConfig.isChecksumVerify(), retryFunction,
- blockInputStreamFactory);
+ .getFromOmKeyInfo(keyInfo, xceiverClientManager, retryFunction,
+ blockInputStreamFactory, clientConfig);
final KeyProvider.KeyVersion decrypted = getDEK(feInfo);
final CryptoInputStream cryptoIn =
new CryptoInputStream(lengthInputStream.getWrappedStream(),
@@ -2250,9 +2250,8 @@ private OzoneInputStream createInputStream(
} else {
// Multipart Key with FileEncryptionInfo
List lengthInputStreams = KeyInputStream
- .getStreamsFromKeyInfo(keyInfo, xceiverClientManager,
- clientConfig.isChecksumVerify(), retryFunction,
- blockInputStreamFactory);
+ .getStreamsFromKeyInfo(keyInfo, xceiverClientManager, retryFunction,
+ blockInputStreamFactory, clientConfig);
final KeyProvider.KeyVersion decrypted = getDEK(feInfo);
List cryptoInputStreams = new ArrayList<>();
@@ -2273,25 +2272,33 @@ private OzoneDataStreamOutput createDataStreamOutput(OpenKeySession openKey)
throws IOException {
final ReplicationConfig replicationConfig
= openKey.getKeyInfo().getReplicationConfig();
+ final ByteBufferStreamOutput out;
+ if (replicationConfig.getReplicationType() == HddsProtos.ReplicationType.RATIS) {
+ KeyDataStreamOutput keyOutputStream = newKeyOutputStreamBuilder()
+ .setHandler(openKey)
+ .setReplicationConfig(replicationConfig)
+ .build();
+ keyOutputStream.addPreallocateBlocks(
+ openKey.getKeyInfo().getLatestVersionLocations(),
+ openKey.getOpenVersion());
+ final OzoneOutputStream secureOut = createSecureOutputStream(openKey, keyOutputStream, null);
+ out = secureOut != null ? secureOut : keyOutputStream;
+ } else {
+ out = createOutputStream(openKey);
+ }
+ return new OzoneDataStreamOutput(out);
+ }
+
+ private KeyDataStreamOutput.Builder newKeyOutputStreamBuilder() {
// Amazon S3 never adds partial objects, So for S3 requests we need to
// set atomicKeyCreation to true
// refer: https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
- KeyDataStreamOutput keyOutputStream =
- new KeyDataStreamOutput.Builder()
- .setHandler(openKey)
- .setXceiverClientManager(xceiverClientManager)
- .setOmClient(ozoneManagerClient)
- .setReplicationConfig(replicationConfig)
- .enableUnsafeByteBufferConversion(unsafeByteBufferConversion)
- .setConfig(clientConfig)
- .setAtomicKeyCreation(isS3GRequest.get())
- .build();
- keyOutputStream
- .addPreallocateBlocks(openKey.getKeyInfo().getLatestVersionLocations(),
- openKey.getOpenVersion());
- final OzoneOutputStream out = createSecureOutputStream(
- openKey, keyOutputStream, null);
- return new OzoneDataStreamOutput(out != null ? out : keyOutputStream);
+ return new KeyDataStreamOutput.Builder()
+ .setXceiverClientManager(xceiverClientManager)
+ .setOmClient(ozoneManagerClient)
+ .enableUnsafeByteBufferConversion(unsafeByteBufferConversion)
+ .setConfig(clientConfig)
+ .setAtomicKeyCreation(isS3GRequest.get());
}
private OzoneOutputStream createOutputStream(OpenKeySession openKey)
diff --git a/hadoop-ozone/client/src/test/java/org/apache/hadoop/ozone/client/io/TestKeyInputStreamEC.java b/hadoop-ozone/client/src/test/java/org/apache/hadoop/ozone/client/io/TestKeyInputStreamEC.java
index 28e9b8ac3c61..df6ef9bc0506 100644
--- a/hadoop-ozone/client/src/test/java/org/apache/hadoop/ozone/client/io/TestKeyInputStreamEC.java
+++ b/hadoop-ozone/client/src/test/java/org/apache/hadoop/ozone/client/io/TestKeyInputStreamEC.java
@@ -20,8 +20,10 @@
import org.apache.hadoop.hdds.client.BlockID;
import org.apache.hadoop.hdds.client.ECReplicationConfig;
import org.apache.hadoop.hdds.client.ReplicationConfig;
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.hadoop.hdds.protocol.DatanodeDetails;
import org.apache.hadoop.hdds.protocol.MockDatanodeDetails;
+import org.apache.hadoop.hdds.scm.OzoneClientConfig;
import org.apache.hadoop.hdds.scm.pipeline.Pipeline;
import org.apache.hadoop.hdds.scm.pipeline.PipelineID;
import org.apache.hadoop.hdds.scm.storage.BlockExtendedInputStream;
@@ -40,7 +42,6 @@
import static org.apache.hadoop.ozone.OzoneConsts.MB;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -49,6 +50,8 @@
*/
public class TestKeyInputStreamEC {
+ private OzoneConfiguration conf = new OzoneConfiguration();
+
@Test
public void testReadAgainstLargeBlockGroup() throws IOException {
int dataBlocks = 10;
@@ -68,10 +71,13 @@ public void testReadAgainstLargeBlockGroup() throws IOException {
BlockInputStreamFactory mockStreamFactory =
mock(BlockInputStreamFactory.class);
when(mockStreamFactory.create(any(), any(), any(), any(),
- anyBoolean(), any(), any())).thenReturn(blockInputStream);
+ any(), any(), any())).thenReturn(blockInputStream);
+ OzoneClientConfig clientConfig = conf.getObject(OzoneClientConfig.class);
+ clientConfig.setChecksumVerify(true);
try (LengthInputStream kis = KeyInputStream.getFromOmKeyInfo(keyInfo,
- null, true, null, mockStreamFactory)) {
+ null, null, mockStreamFactory,
+ clientConfig)) {
byte[] buf = new byte[100];
int readBytes = kis.read(buf, 0, 100);
Assertions.assertEquals(100, readBytes);
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java
index babeb3054875..1767cdb6dc3a 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/OmUtils.java
@@ -721,6 +721,47 @@ public static String normalizeKey(String keyName,
return keyName;
}
+ /**
+ * Normalizes a given path up to the bucket level.
+ *
+ * This method takes a path as input and normalises uptil the bucket level.
+ * It handles empty, removes leading slashes, and splits the path into
+ * segments. It then extracts the volume and bucket names, forming a
+ * normalized path with a single slash. Finally, any remaining segments are
+ * joined as the key name, returning the complete standardized path.
+ *
+ * @param path The path string to be normalized.
+ * @return The normalized path string.
+ */
+ public static String normalizePathUptoBucket(String path) {
+ if (path == null || path.isEmpty()) {
+ return OM_KEY_PREFIX; // Handle empty path
+ }
+
+ // Remove leading slashes
+ path = path.replaceAll("^/*", "");
+
+ String[] segments = path.split(OM_KEY_PREFIX, -1);
+
+ String volumeName = segments[0];
+ String bucketName = segments.length > 1 ? segments[1] : "";
+
+ // Combine volume and bucket.
+ StringBuilder normalizedPath = new StringBuilder(volumeName);
+ if (!bucketName.isEmpty()) {
+ normalizedPath.append(OM_KEY_PREFIX).append(bucketName);
+ }
+
+ // Add remaining segments as the key
+ if (segments.length > 2) {
+ normalizedPath.append(OM_KEY_PREFIX).append(
+ String.join(OM_KEY_PREFIX,
+ Arrays.copyOfRange(segments, 2, segments.length)));
+ }
+
+ return normalizedPath.toString();
+ }
+
/**
* For a given service ID, return list of configured OM hosts.
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/OMConfigKeys.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/OMConfigKeys.java
index 5dd7579eb916..9b844cc74fdf 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/OMConfigKeys.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/OMConfigKeys.java
@@ -579,13 +579,20 @@ private OMConfigKeys() {
= TimeUnit.DAYS.toMillis(7);
public static final String OZONE_OM_SNAPSHOT_DIFF_CLEANUP_SERVICE_RUN_INTERVAL
- = "ozone.om.snapshot.diff.cleanup.service.run.internal";
+ = "ozone.om.snapshot.diff.cleanup.service.run.interval";
+ public static final String
+ OZONE_OM_SNAPSHOT_CACHE_CLEANUP_SERVICE_RUN_INTERVAL
+ = "ozone.om.snapshot.cache.cleanup.service.run.interval";
public static final long
OZONE_OM_SNAPSHOT_DIFF_CLEANUP_SERVICE_RUN_INTERVAL_DEFAULT
= TimeUnit.MINUTES.toMillis(1);
+ public static final long
+ OZONE_OM_SNAPSHOT_CACHE_CLEANUP_SERVICE_RUN_INTERVAL_DEFAULT
+ = TimeUnit.MINUTES.toMillis(1);
public static final String OZONE_OM_SNAPSHOT_DIFF_CLEANUP_SERVICE_TIMEOUT
= "ozone.om.snapshot.diff.cleanup.service.timeout";
+
public static final long
OZONE_OM_SNAPSHOT_DIFF_CLEANUP_SERVICE_TIMEOUT_DEFAULT
= TimeUnit.MINUTES.toMillis(5);
diff --git a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/snapshot/SnapshotDiffReportOzone.java b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/snapshot/SnapshotDiffReportOzone.java
index 3d14e266daa4..29bf4deb2a08 100644
--- a/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/snapshot/SnapshotDiffReportOzone.java
+++ b/hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/snapshot/SnapshotDiffReportOzone.java
@@ -101,16 +101,12 @@ public String toString() {
.append(" and snapshot: ")
.append(getLaterSnapshotName())
.append(LINE_SEPARATOR);
- if (!getDiffList().isEmpty()) {
- for (DiffReportEntry entry : getDiffList()) {
- str.append(entry.toString()).append(LINE_SEPARATOR);
- }
- if (StringUtils.isNotEmpty(token)) {
- str.append("Next token: ")
- .append(token);
- }
- } else {
- str.append("No diff or no more diff for the request parameters.");
+ for (DiffReportEntry entry : getDiffList()) {
+ str.append(entry.toString()).append(LINE_SEPARATOR);
+ }
+ if (StringUtils.isNotEmpty(token)) {
+ str.append("Next token: ")
+ .append(token);
}
return str.toString();
}
diff --git a/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config b/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config
index 53f1a63d97ae..f5c32ff3aa2c 100644
--- a/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config
+++ b/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config
@@ -84,7 +84,8 @@ OZONE-SITE.XML_ozone.scm.dead.node.interval=45s
OZONE-SITE.XML_hdds.container.report.interval=60s
OZONE-SITE.XML_ozone.scm.close.container.wait.duration=5s
-OZONE-SITE.XML_dfs.container.ratis.datastream.enabled=true
+# Ratis streaming is disabled to ensure coverage for both cases
+OZONE-SITE.XML_dfs.container.ratis.datastream.enabled=false
HDFS-SITE.XML_dfs.datanode.kerberos.principal=dn/dn@EXAMPLE.COM
HDFS-SITE.XML_dfs.datanode.kerberos.keytab.file=/etc/security/keytabs/dn.keytab
@@ -114,7 +115,7 @@ OZONE-SITE.XML_ozone.s3g.http.auth.kerberos.keytab=/etc/security/keytabs/s3g.key
OZONE-SITE.XML_ozone.s3g.http.auth.kerberos.principal=HTTP/s3g@EXAMPLE.COM
OZONE-SITE.XML_ozone.httpfs.http.auth.kerberos.keytab=/etc/security/keytabs/httpfs.keytab
OZONE-SITE.XML_ozone.httpfs.http.auth.kerberos.principal=HTTP/httpfs@EXAMPLE.COM
-OZONE-SITE.XML_ozone.recon.http.auth.kerberos.principal=HTTP/recon@EXAMPLE.COM
+OZONE-SITE.XML_ozone.recon.http.auth.kerberos.principal=*
OZONE-SITE.XML_ozone.recon.http.auth.kerberos.keytab=/etc/security/keytabs/recon.keytab
CORE-SITE.XML_hadoop.http.authentication.simple.anonymous.allowed=false
diff --git a/hadoop-ozone/dist/src/main/compose/ozonesecure/test.sh b/hadoop-ozone/dist/src/main/compose/ozonesecure/test.sh
index 41f4fa9a580f..6d213f9b5fbe 100755
--- a/hadoop-ozone/dist/src/main/compose/ozonesecure/test.sh
+++ b/hadoop-ozone/dist/src/main/compose/ozonesecure/test.sh
@@ -39,6 +39,15 @@ execute_robot_test scm security
execute_robot_test scm -v SCHEME:ofs -v BUCKET_TYPE:bucket -N ozonefs-ofs-bucket ozonefs/ozonefs.robot
+## Exclude virtual-host tests. This is tested separately as it requires additional config.
+exclude="--exclude virtual-host"
+for bucket in encrypted; do
+ execute_robot_test s3g -v BUCKET:${bucket} -N s3-${bucket} ${exclude} s3
+ # some tests are independent of the bucket type, only need to be run once
+ ## Exclude virtual-host.robot
+ exclude="--exclude virtual-host --exclude no-bucket-type"
+done
+
#expects 4 pipelines, should be run before
#admincli which creates STANDALONE pipeline
execute_robot_test scm recon
diff --git a/hadoop-ozone/dist/src/main/compose/testlib.sh b/hadoop-ozone/dist/src/main/compose/testlib.sh
index c13ca1bb80e0..505cb1ae77c9 100755
--- a/hadoop-ozone/dist/src/main/compose/testlib.sh
+++ b/hadoop-ozone/dist/src/main/compose/testlib.sh
@@ -304,9 +304,10 @@ get_output_name() {
save_container_logs() {
local output_name=$(get_output_name)
- local c
- for c in $(docker-compose ps "$@" | cut -f1 -d' ' | tail -n +3); do
- docker logs "${c}" >> "$RESULT_DIR/docker-${output_name}${c}.log" 2>&1
+ local id
+ for i in $(docker-compose ps -a -q "$@"); do
+ local c=$(docker ps -a --filter "id=${i}" --format "{{ .Names }}")
+ docker logs "${i}" >> "$RESULT_DIR/docker-${output_name}${c}.log" 2>&1
done
}
diff --git a/hadoop-ozone/dist/src/main/license/jar-report.txt b/hadoop-ozone/dist/src/main/license/jar-report.txt
index b4f83965f4a1..49473afb73d1 100644
--- a/hadoop-ozone/dist/src/main/license/jar-report.txt
+++ b/hadoop-ozone/dist/src/main/license/jar-report.txt
@@ -163,7 +163,10 @@ share/ozone/lib/jsp-api.jar
share/ozone/lib/jsr305.jar
share/ozone/lib/jsr311-api.jar
share/ozone/lib/kerb-core.jar
+share/ozone/lib/kerb-crypto.jar
+share/ozone/lib/kerb-util.jar
share/ozone/lib/kerby-asn1.jar
+share/ozone/lib/kerby-config.jar
share/ozone/lib/kerby-pkix.jar
share/ozone/lib/kerby-util.jar
share/ozone/lib/kotlin-stdlib-common.jar
diff --git a/hadoop-ozone/integration-test/dev-support/findbugsExcludeFile.xml b/hadoop-ozone/integration-test/dev-support/findbugsExcludeFile.xml
index 098d27980c3a..3b7a676f28bf 100644
--- a/hadoop-ozone/integration-test/dev-support/findbugsExcludeFile.xml
+++ b/hadoop-ozone/integration-test/dev-support/findbugsExcludeFile.xml
@@ -36,10 +36,6 @@
-
-
-
-
@@ -125,10 +121,6 @@
-
-
-
-
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystem.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTest.java
similarity index 70%
rename from hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystem.java
rename to hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTest.java
index b5d83704833c..a83c7bf16a2e 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystem.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTest.java
@@ -18,14 +18,17 @@
package org.apache.hadoop.fs.ozone;
+import org.apache.commons.lang3.RandomStringUtils;
import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.fs.CommonConfigurationKeysPublic;
+import org.apache.hadoop.conf.StorageUnit;
+import org.apache.hadoop.fs.BlockLocation;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileAlreadyExistsException;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.InvalidPathException;
+import org.apache.hadoop.fs.LocatedFileStatus;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.fs.PathIsNotEmptyDirectoryException;
@@ -53,6 +56,8 @@
import org.apache.hadoop.ozone.client.OzoneKeyDetails;
import org.apache.hadoop.ozone.client.OzoneVolume;
import org.apache.hadoop.ozone.om.OMConfigKeys;
+import org.apache.hadoop.ozone.om.OMMetadataManager;
+import org.apache.hadoop.ozone.om.OMMetrics;
import org.apache.hadoop.ozone.om.OzonePrefixPathImpl;
import org.apache.hadoop.ozone.om.TrashPolicyOzone;
import org.apache.hadoop.ozone.om.exceptions.OMException;
@@ -62,17 +67,14 @@
import org.apache.hadoop.ozone.om.helpers.OzoneFileStatus;
import org.apache.hadoop.ozone.om.protocol.OzoneManagerProtocol;
import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hadoop.util.Time;
import org.apache.ozone.test.GenericTestUtils;
import org.apache.ozone.test.TestClock;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestRule;
-import org.junit.rules.Timeout;
-import org.apache.ozone.test.JUnit5AwareTimeout;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.event.Level;
@@ -88,38 +90,48 @@
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.UUID;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.apache.hadoop.fs.CommonConfigurationKeysPublic.FS_DEFAULT_NAME_KEY;
import static org.apache.hadoop.fs.CommonConfigurationKeysPublic.FS_TRASH_CHECKPOINT_INTERVAL_KEY;
import static org.apache.hadoop.fs.CommonConfigurationKeysPublic.FS_TRASH_INTERVAL_KEY;
import static org.apache.hadoop.fs.CommonPathCapabilities.FS_ACLS;
import static org.apache.hadoop.fs.CommonPathCapabilities.FS_CHECKSUMS;
import static org.apache.hadoop.fs.FileSystem.TRASH_PREFIX;
+import static org.apache.hadoop.fs.StorageStatistics.CommonStatisticNames.OP_CREATE;
+import static org.apache.hadoop.fs.StorageStatistics.CommonStatisticNames.OP_GET_FILE_STATUS;
+import static org.apache.hadoop.fs.StorageStatistics.CommonStatisticNames.OP_MKDIRS;
+import static org.apache.hadoop.fs.StorageStatistics.CommonStatisticNames.OP_OPEN;
import static org.apache.hadoop.fs.contract.ContractTestUtils.assertHasPathCapabilities;
import static org.apache.hadoop.fs.ozone.Constants.LISTING_PAGE_SIZE;
+import static org.apache.hadoop.fs.ozone.Constants.OZONE_DEFAULT_USER;
import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.ONE;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_ACL_ENABLED;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_FS_ITERATE_BATCH_SIZE;
import static org.apache.hadoop.ozone.OzoneConsts.OM_KEY_PREFIX;
import static org.apache.hadoop.ozone.OzoneConsts.OZONE_URI_DELIMITER;
import static org.apache.hadoop.ozone.om.helpers.BucketLayout.FILE_SYSTEM_OPTIMIZED;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
/**
* Ozone file system tests that are not covered by contract tests.
*/
-@RunWith(Parameterized.class)
-public class TestOzoneFileSystem {
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+abstract class AbstractOzoneFileSystemTest {
private static final float TRASH_INTERVAL = 0.05f; // 3 seconds
@@ -131,59 +143,35 @@ public class TestOzoneFileSystem {
private static final PathFilter EXCLUDE_TRASH =
p -> !p.toUri().getPath().startsWith(TRASH_ROOT.toString());
+ private String fsRoot;
- @Parameterized.Parameters
- public static Collection data() {
- return Arrays.asList(
- new Object[]{true, true},
- new Object[]{true, false},
- new Object[]{false, true},
- new Object[]{false, false});
- }
-
- public TestOzoneFileSystem(boolean setDefaultFs, boolean enableOMRatis) {
- // Checking whether 'defaultFS' and 'omRatis' flags represents next
- // parameter index values. This is to ensure that initialize
- // TestOzoneFileSystem#init() function will be invoked only at the
- // beginning of every new set of Parameterized.Parameters.
- if (enabledFileSystemPaths != setDefaultFs ||
- omRatisEnabled != enableOMRatis || cluster == null) {
- enabledFileSystemPaths = setDefaultFs;
- omRatisEnabled = enableOMRatis;
- try {
- teardown();
- init();
- } catch (Exception e) {
- LOG.info("Unexpected exception", e);
- fail("Unexpected exception:" + e.getMessage());
- }
- }
+ AbstractOzoneFileSystemTest(boolean setDefaultFs, boolean enableOMRatis, BucketLayout layout) {
+ enabledFileSystemPaths = setDefaultFs;
+ omRatisEnabled = enableOMRatis;
+ bucketLayout = layout;
}
- /**
- * Set a timeout for each test.
- */
- @Rule
- public TestRule timeout = new JUnit5AwareTimeout(Timeout.seconds(600));
-
private static final Logger LOG =
- LoggerFactory.getLogger(TestOzoneFileSystem.class);
-
- private static BucketLayout bucketLayout = BucketLayout.LEGACY;
- private static boolean enabledFileSystemPaths;
- private static boolean omRatisEnabled;
-
- private static MiniOzoneCluster cluster;
- private static OzoneClient client;
- private static OzoneManagerProtocol writeClient;
- private static FileSystem fs;
- private static OzoneFileSystem o3fs;
- private static OzoneBucket ozoneBucket;
- private static String volumeName;
- private static String bucketName;
- private static Trash trash;
-
- private void init() throws Exception {
+ LoggerFactory.getLogger(AbstractOzoneFileSystemTest.class);
+
+ private final BucketLayout bucketLayout;
+ private final boolean enabledFileSystemPaths;
+ private final boolean omRatisEnabled;
+
+ private MiniOzoneCluster cluster;
+ private OzoneClient client;
+ private OzoneManagerProtocol writeClient;
+ private FileSystem fs;
+ private OzoneFileSystem o3fs;
+ private OzoneFSStorageStatistics statistics;
+ private OzoneBucket ozoneBucket;
+ private String volumeName;
+ private String bucketName;
+ private Trash trash;
+ private OMMetrics omMetrics;
+
+ @BeforeAll
+ void init() throws Exception {
OzoneConfiguration conf = new OzoneConfiguration();
conf.setFloat(OMConfigKeys.OZONE_FS_TRASH_INTERVAL_KEY, TRASH_INTERVAL);
conf.setFloat(FS_TRASH_INTERVAL_KEY, TRASH_INTERVAL);
@@ -202,6 +190,7 @@ private void init() throws Exception {
.setNumDatanodes(5)
.build();
cluster.waitForClusterToBeReady();
+ omMetrics = cluster.getOzoneManager().getMetrics();
client = cluster.newClient();
writeClient = client.getObjectStore()
@@ -211,21 +200,24 @@ private void init() throws Exception {
volumeName = ozoneBucket.getVolumeName();
bucketName = ozoneBucket.getName();
- String rootPath = String.format("%s://%s.%s/",
- OzoneConsts.OZONE_URI_SCHEME, bucketName, volumeName);
+ fsRoot = String.format("%s://%s.%s/",
+ OzoneConsts.OZONE_URI_SCHEME, bucketName, volumeName);
// Set the fs.defaultFS and start the filesystem
- conf.set(CommonConfigurationKeysPublic.FS_DEFAULT_NAME_KEY, rootPath);
+ conf.set(FS_DEFAULT_NAME_KEY, fsRoot);
// Set the number of keys to be processed during batch operate.
conf.setInt(OZONE_FS_ITERATE_BATCH_SIZE, 5);
fs = FileSystem.get(conf);
trash = new Trash(conf);
- o3fs = (OzoneFileSystem) fs;
+ o3fs = assertInstanceOf(OzoneFileSystem.class, fs);
+ statistics = (OzoneFSStorageStatistics) o3fs.getOzoneFSOpsCountStatistics();
+ assertEquals(OzoneConsts.OZONE_URI_SCHEME, fs.getUri().getScheme());
+ assertEquals(OzoneConsts.OZONE_URI_SCHEME, statistics.getScheme());
}
- @AfterClass
- public static void teardown() {
+ @AfterAll
+ void teardown() {
IOUtils.closeQuietly(client);
if (cluster != null) {
cluster.shutdown();
@@ -233,7 +225,7 @@ public static void teardown() {
IOUtils.closeQuietly(fs);
}
- @After
+ @AfterEach
public void cleanup() {
try {
deleteRootDir();
@@ -243,28 +235,24 @@ public void cleanup() {
}
}
- public static MiniOzoneCluster getCluster() {
+ public MiniOzoneCluster getCluster() {
return cluster;
}
- public static FileSystem getFs() {
+ public FileSystem getFs() {
return fs;
}
- public static void setBucketLayout(BucketLayout bLayout) {
- bucketLayout = bLayout;
- }
-
- public static String getBucketName() {
+ public String getBucketName() {
return bucketName;
}
- public static String getVolumeName() {
+ public String getVolumeName() {
return volumeName;
}
public BucketLayout getBucketLayout() {
- return BucketLayout.DEFAULT;
+ return bucketLayout;
}
@Test
@@ -284,7 +272,7 @@ public void testCreateFileShouldCheckExistenceOfDirWithSameName()
Path parent = new Path("/d1/d2/d3/d4/");
Path file1 = new Path(parent, "key1");
try (FSDataOutputStream outputStream = fs.create(file1, false)) {
- assertNotNull("Should be able to create file", outputStream);
+ assertNotNull(outputStream, "Should be able to create file");
}
Path dir1 = new Path("/d1/d2/d3/d4/key2");
@@ -297,7 +285,7 @@ public void testCreateFileShouldCheckExistenceOfDirWithSameName()
Path file2 = new Path("/d1/d2/d3/d4/key3");
try (FSDataOutputStream outputStream2 = fs.create(file2, false)) {
- assertNotNull("Should be able to create file", outputStream2);
+ assertNotNull(outputStream2, "Should be able to create file");
}
try {
fs.mkdirs(file2);
@@ -316,10 +304,8 @@ public void testCreateFileShouldCheckExistenceOfDirWithSameName()
// Directory
FileStatus fileStatus = fs.getFileStatus(parent);
- assertEquals("FileStatus did not return the directory",
- "/d1/d2/d3/d4", fileStatus.getPath().toUri().getPath());
- assertTrue("FileStatus did not return the directory",
- fileStatus.isDirectory());
+ assertEquals("/d1/d2/d3/d4", fileStatus.getPath().toUri().getPath());
+ assertTrue(fileStatus.isDirectory());
// invalid sub directory
try {
@@ -351,12 +337,12 @@ public void testMakeDirsWithAnExistingDirectoryPath() throws Exception {
Path parent = new Path("/d1/d2/d3/d4/");
Path file1 = new Path(parent, "key1");
try (FSDataOutputStream outputStream = fs.create(file1, false)) {
- assertNotNull("Should be able to create file", outputStream);
+ assertNotNull(outputStream, "Should be able to create file");
}
Path subdir = new Path("/d1/d2/");
boolean status = fs.mkdirs(subdir);
- assertTrue("Shouldn't send error if dir exists", status);
+ assertTrue(status, "Shouldn't send error if dir exists");
}
@Test
@@ -412,9 +398,8 @@ private void checkInvalidPath(Path path) {
public void testOzoneFsServiceLoader() throws IOException {
assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
- assertEquals(
- FileSystem.getFileSystemClass(OzoneConsts.OZONE_URI_SCHEME, null),
- OzoneFileSystem.class);
+ assertEquals(OzoneFileSystem.class,
+ FileSystem.getFileSystemClass(OzoneConsts.OZONE_URI_SCHEME, null));
}
@Test
@@ -435,10 +420,8 @@ public void testCreateDoesNotAddParentDirKeys() throws Exception {
}
// List status on the parent should show the child file
- assertEquals("List status of parent should include the 1 child file", 1L,
- fs.listStatus(parent).length);
- assertTrue("Parent directory does not appear to be a directory",
- fs.getFileStatus(parent).isDirectory());
+ assertEquals(1L, fs.listStatus(parent).length, "List status of parent should include the 1 child file");
+ assertTrue(fs.getFileStatus(parent).isDirectory(), "Parent directory does not appear to be a directory");
}
@Test
@@ -601,22 +584,19 @@ public void testListStatus() throws Exception {
Path file2 = new Path(parent, "key2");
FileStatus[] fileStatuses = o3fs.listStatus(ROOT, EXCLUDE_TRASH);
- assertEquals("Should be empty", 0, fileStatuses.length);
+ assertEquals(0, fileStatuses.length, "Should be empty");
ContractTestUtils.touch(fs, file1);
ContractTestUtils.touch(fs, file2);
fileStatuses = o3fs.listStatus(ROOT, EXCLUDE_TRASH);
- assertEquals("Should have created parent",
- 1, fileStatuses.length);
- assertEquals("Parent path doesn't match",
- fileStatuses[0].getPath().toUri().getPath(), parent.toString());
+ assertEquals(1, fileStatuses.length, "Should have created parent");
+ assertEquals(fileStatuses[0].getPath().toUri().getPath(), parent.toString(), "Parent path doesn't match");
// ListStatus on a directory should return all subdirs along with
// files, even if there exists a file and sub-dir with the same name.
fileStatuses = o3fs.listStatus(parent);
- assertEquals("FileStatus did not return all children of the directory",
- 2, fileStatuses.length);
+ assertEquals(2, fileStatuses.length, "FileStatus did not return all children of the directory");
// ListStatus should return only the immediate children of a directory.
Path file3 = new Path(parent, "dir1/key3");
@@ -624,8 +604,7 @@ public void testListStatus() throws Exception {
ContractTestUtils.touch(fs, file3);
ContractTestUtils.touch(fs, file4);
fileStatuses = o3fs.listStatus(parent);
- assertEquals("FileStatus did not return all children of the directory",
- 3, fileStatuses.length);
+ assertEquals(3, fileStatuses.length, "FileStatus did not return all children of the directory");
}
@Test
@@ -661,7 +640,7 @@ public void testListStatusWithIntermediateDir() throws Exception {
FileStatus[] fileStatuses = fs.listStatus(ROOT, EXCLUDE_TRASH);
// the number of immediate children of root is 1
- assertEquals(Arrays.toString(fileStatuses), 1, fileStatuses.length);
+ assertEquals(1, fileStatuses.length, Arrays.toString(fileStatuses));
writeClient.deleteKey(keyArgs);
}
@@ -694,8 +673,7 @@ public void testListStatusWithIntermediateDirWithECEnabled()
FileStatus[] fileStatuses = fs.listStatus(ROOT, EXCLUDE_TRASH);
// the number of immediate children of root is 1
assertEquals(1, fileStatuses.length);
- assertEquals(fileStatuses[0].isErasureCoded(),
- !bucketLayout.isFileSystemOptimized());
+ assertEquals(fileStatuses[0].isErasureCoded(), !bucketLayout.isFileSystemOptimized());
fileStatuses = fs.listStatus(new Path(
fileStatuses[0].getPath().toString() + "/object-name1"));
assertEquals(1, fileStatuses.length);
@@ -718,8 +696,7 @@ public void testListStatusOnRoot() throws Exception {
// exist) and dir2 only. dir12 is not an immediate child of root and
// hence should not be listed.
FileStatus[] fileStatuses = o3fs.listStatus(ROOT, EXCLUDE_TRASH);
- assertEquals("FileStatus should return only the immediate children",
- 2, fileStatuses.length);
+ assertEquals(2, fileStatuses.length, "FileStatus should return only the immediate children");
// Verify that dir12 is not included in the result of the listStatus on root
String fileStatus1 = fileStatuses[0].getPath().toUri().getPath();
@@ -767,9 +744,7 @@ public void testListStatusOnLargeDirectory() throws Exception {
LOG.info("actualPathList: {}", actualPathList);
}
}
- assertEquals(
- "Total directories listed do not match the existing directories",
- numDirs, fileStatuses.length);
+ assertEquals(numDirs, fileStatuses.length, "Total directories listed do not match the existing directories");
for (int i = 0; i < numDirs; i++) {
assertTrue(paths.contains(fileStatuses[i].getPath().getName()));
@@ -802,8 +777,7 @@ public void testListStatusOnKeyNameContainDelimiter() throws Exception {
fileStatuses = fs.listStatus(new Path("/dir1/dir2"));
assertEquals(1, fileStatuses.length);
- assertEquals("/dir1/dir2/key1",
- fileStatuses[0].getPath().toUri().getPath());
+ assertEquals("/dir1/dir2/key1", fileStatuses[0].getPath().toUri().getPath());
assertTrue(fileStatuses[0].isFile());
}
@@ -824,11 +798,11 @@ protected void deleteRootDir() throws IOException, InterruptedException {
for (FileStatus fileStatus : fileStatuses) {
LOG.error("Unexpected file, should have been deleted: {}", fileStatus);
}
- assertEquals("Delete root failed!", 0, fileStatuses.length);
+ assertEquals(0, fileStatuses.length, "Delete root failed!");
}
}
- private static void deleteRootRecursively(FileStatus[] fileStatuses)
+ private void deleteRootRecursively(FileStatus[] fileStatuses)
throws IOException {
for (FileStatus fStatus : fileStatuses) {
fs.delete(fStatus.getPath(), true);
@@ -861,8 +835,7 @@ public void testListStatusOnSubDirs() throws Exception {
fs.mkdirs(dir2);
FileStatus[] fileStatuses = o3fs.listStatus(dir1);
- assertEquals("FileStatus should return only the immediate children", 2,
- fileStatuses.length);
+ assertEquals(2, fileStatuses.length, "FileStatus should return only the immediate children");
// Verify that the two children of /dir1 returned by listStatus operation
// are /dir1/dir11 and /dir1/dir12.
@@ -894,8 +867,7 @@ public void testListStatusIteratorWithDir() throws Exception {
while (it.hasNext()) {
FileStatus fileStatus = it.next();
assertNotNull(fileStatus);
- assertEquals("Parent path doesn't match",
- fileStatus.getPath().toUri().getPath(), parent.toString());
+ assertEquals(fileStatus.getPath().toUri().getPath(), parent.toString(), "Parent path doesn't match");
}
// Iterator on a directory should return all subdirs along with
// files, even if there exists a file and sub-dir with the same name.
@@ -906,9 +878,7 @@ public void testListStatusIteratorWithDir() throws Exception {
FileStatus fileStatus = it.next();
assertNotNull(fileStatus);
}
- assertEquals(
- "Iterator did not return all the file status",
- 2, iCount);
+ assertEquals(2, iCount, "Iterator did not return all the file status");
// Iterator should return file status for only the
// immediate children of a directory.
Path file3 = new Path(parent, "dir1/key3");
@@ -923,8 +893,8 @@ public void testListStatusIteratorWithDir() throws Exception {
FileStatus fileStatus = it.next();
assertNotNull(fileStatus);
}
- assertEquals("Iterator did not return file status " +
- "of all the children of the directory", 3, iCount);
+ assertEquals(3, iCount, "Iterator did not return file status " +
+ "of all the children of the directory");
} finally {
// Cleanup
@@ -955,11 +925,9 @@ public void testListStatusIteratorOnRoot() throws Exception {
assertNotNull(fileStatus);
// Verify that dir12 is not included in the result
// of the listStatusIterator on root.
- assertNotEquals(fileStatus.getPath().toUri().getPath(),
- dir12.toString());
+ assertNotEquals(fileStatus.getPath().toUri().getPath(), dir12.toString());
}
- assertEquals("FileStatus should return only the immediate children",
- 2, iCount);
+ assertEquals(2, iCount, "FileStatus should return only the immediate children");
} finally {
// Cleanup
fs.delete(dir2, true);
@@ -1010,8 +978,7 @@ public void testListStatusIteratorOnSubDirs() throws Exception {
equals(dir11.toString()) || fileStatus.getPath().toUri().getPath()
.equals(dir12.toString()));
}
- assertEquals("FileStatus should return only the immediate children", 2,
- iCount);
+ assertEquals(2, iCount, "FileStatus should return only the immediate children");
} finally {
// Cleanup
fs.delete(dir2, true);
@@ -1035,8 +1002,7 @@ public void testSeekOnFileLength() throws IOException {
fs.open(fileNotExists);
fail("Should throw FileNotFoundException as file doesn't exist!");
} catch (FileNotFoundException fnfe) {
- assertTrue("Expected KEY_NOT_FOUND error",
- fnfe.getMessage().contains("KEY_NOT_FOUND"));
+ assertTrue(fnfe.getMessage().contains("KEY_NOT_FOUND"), "Expected KEY_NOT_FOUND error");
}
}
@@ -1059,14 +1025,12 @@ public void testAllocateMoreThanOneBlock() throws IOException {
FileStatus fileStatus = fs.getFileStatus(file);
long blkSize = fileStatus.getBlockSize();
long fileLength = fileStatus.getLen();
- assertTrue("Block allocation should happen",
- fileLength > blkSize);
+ assertTrue(fileLength > blkSize, "Block allocation should happen");
long newNumBlockAllocations =
cluster.getOzoneManager().getMetrics().getNumBlockAllocates();
- assertTrue("Block allocation should happen",
- (newNumBlockAllocations > numBlockAllocationsOrg));
+ assertTrue((newNumBlockAllocations > numBlockAllocationsOrg), "Block allocation should happen");
stream.seek(fileLength);
assertEquals(-1, stream.read());
@@ -1097,11 +1061,10 @@ public void testNonExplicitlyCreatedPathExistsAfterItsLeafsWereRemoved()
// after rename listStatus for interimPath should succeed and
// interimPath should have no children
FileStatus[] statuses = fs.listStatus(interimPath);
- assertNotNull("liststatus returns a null array", statuses);
- assertEquals("Statuses array is not empty", 0, statuses.length);
+ assertNotNull(statuses, "liststatus returns a null array");
+ assertEquals(0, statuses.length, "Statuses array is not empty");
FileStatus fileStatus = fs.getFileStatus(interimPath);
- assertEquals("FileStatus does not point to interimPath",
- interimPath.getName(), fileStatus.getPath().getName());
+ assertEquals(interimPath.getName(), fileStatus.getPath().getName(), "FileStatus does not point to interimPath");
}
/**
@@ -1120,8 +1083,7 @@ public void testRenameWithNonExistentSource() throws Exception {
LOG.info("Created destin dir: {}", destin);
LOG.info("Rename op-> source:{} to destin:{}}", source, destin);
- assertFalse("Expected to fail rename as src doesn't exist",
- fs.rename(source, destin));
+ assertFalse(fs.rename(source, destin), "Expected to fail rename as src doesn't exist");
}
/**
@@ -1188,12 +1150,12 @@ public void testRenameToExistingDir() throws Exception {
fs.mkdirs(acPath);
// Rename from /a to /b.
- assertTrue("Rename failed", fs.rename(aSourcePath, bDestinPath));
+ assertTrue(fs.rename(aSourcePath, bDestinPath), "Rename failed");
final Path baPath = new Path(fs.getUri().toString() + "/b/a");
final Path bacPath = new Path(fs.getUri().toString() + "/b/a/c");
- assertTrue("Rename failed", fs.exists(baPath));
- assertTrue("Rename failed", fs.exists(bacPath));
+ assertTrue(fs.exists(baPath), "Rename failed");
+ assertTrue(fs.exists(bacPath), "Rename failed");
}
/**
@@ -1219,8 +1181,7 @@ public void testRenameToNewSubDirShouldNotExist() throws Exception {
final Path baPath = new Path(fs.getUri().toString() + "/b/a/c");
fs.mkdirs(baPath);
- assertFalse("New destin sub-path /b/a already exists",
- fs.rename(aSourcePath, bDestinPath));
+ assertFalse(fs.rename(aSourcePath, bDestinPath), "New destin sub-path /b/a already exists");
// Case-5.b) Rename file from /a/b/c/file1 to /a.
// Should be failed since /a/file1 exists.
@@ -1234,8 +1195,7 @@ public void testRenameToNewSubDirShouldNotExist() throws Exception {
final Path aDestinPath = new Path(fs.getUri().toString() + "/a");
- assertFalse("New destin sub-path /b/a already exists",
- fs.rename(abcFile1, aDestinPath));
+ assertFalse(fs.rename(abcFile1, aDestinPath), "New destin sub-path /b/a already exists");
}
/**
@@ -1251,8 +1211,7 @@ public void testRenameDirToFile() throws Exception {
ContractTestUtils.touch(fs, file1Destin);
Path abcRootPath = new Path(fs.getUri().toString() + "/a/b/c");
fs.mkdirs(abcRootPath);
- assertFalse("key already exists /root_dir/file1",
- fs.rename(abcRootPath, file1Destin));
+ assertFalse(fs.rename(abcRootPath, file1Destin), "key already exists /root_dir/file1");
}
/**
@@ -1268,18 +1227,18 @@ public void testRenameFile() throws Exception {
+ "/file1_Copy");
ContractTestUtils.touch(fs, file1Source);
Path file1Destin = new Path(fs.getUri().toString() + root + "/file1");
- assertTrue("Renamed failed", fs.rename(file1Source, file1Destin));
- assertTrue("Renamed failed: /root/file1", fs.exists(file1Destin));
+ assertTrue(fs.rename(file1Source, file1Destin), "Renamed failed");
+ assertTrue(fs.exists(file1Destin), "Renamed failed: /root/file1");
- /**
+ /*
* Reading several times, this is to verify that OmKeyInfo#keyName cached
* entry is not modified. While reading back, OmKeyInfo#keyName will be
* prepared and assigned to fullkeyPath name.
*/
for (int i = 0; i < 10; i++) {
FileStatus[] fStatus = fs.listStatus(rootPath);
- assertEquals("Renamed failed", 1, fStatus.length);
- assertEquals("Wrong path name!", file1Destin, fStatus[0].getPath());
+ assertEquals(1, fStatus.length, "Renamed failed");
+ assertEquals(file1Destin, fStatus[0].getPath(), "Wrong path name!");
}
}
@@ -1296,9 +1255,9 @@ public void testRenameFileToDir() throws Exception {
ContractTestUtils.touch(fs, file1Destin);
Path abcRootPath = new Path(fs.getUri().toString() + "/a/b/c");
fs.mkdirs(abcRootPath);
- assertTrue("Renamed failed", fs.rename(file1Destin, abcRootPath));
- assertTrue("Renamed filed: /a/b/c/file1", fs.exists(new Path(abcRootPath,
- "file1")));
+ assertTrue(fs.rename(file1Destin, abcRootPath), "Renamed failed");
+ assertTrue(fs.exists(new Path(abcRootPath,
+ "file1")), "Renamed filed: /a/b/c/file1");
}
@Test
@@ -1374,18 +1333,16 @@ public void testRenameToParentDir() throws Exception {
ContractTestUtils.touch(fs, file1Source);
// rename source directory to its parent directory(destination).
- assertTrue("Rename failed", fs.rename(dir2SourcePath, destRootPath));
+ assertTrue(fs.rename(dir2SourcePath, destRootPath), "Rename failed");
final Path expectedPathAfterRename =
new Path(fs.getUri().toString() + root + "/dir2");
- assertTrue("Rename failed",
- fs.exists(expectedPathAfterRename));
+ assertTrue(fs.exists(expectedPathAfterRename), "Rename failed");
// rename source file to its parent directory(destination).
- assertTrue("Rename failed", fs.rename(file1Source, destRootPath));
+ assertTrue(fs.rename(file1Source, destRootPath), "Rename failed");
final Path expectedFilePathAfterRename =
new Path(fs.getUri().toString() + root + "/file2");
- assertTrue("Rename failed",
- fs.exists(expectedFilePathAfterRename));
+ assertTrue(fs.exists(expectedFilePathAfterRename), "Rename failed");
}
@Test
@@ -1399,11 +1356,10 @@ public void testRenameDir() throws Exception {
LOG.info("Created dir {}", subdir);
LOG.info("Will move {} to {}", source, dest);
fs.rename(source, dest);
- assertTrue("Directory rename failed", fs.exists(dest));
+ assertTrue(fs.exists(dest), "Directory rename failed");
// Verify that the subdir is also renamed i.e. keys corresponding to the
// sub-directories of the renamed directory have also been renamed.
- assertTrue("Keys under the renamed directory not renamed",
- fs.exists(new Path(dest, "sub_dir1")));
+ assertTrue(fs.exists(new Path(dest, "sub_dir1")), "Keys under the renamed directory not renamed");
// Test if one path belongs to other FileSystem.
IllegalArgumentException exception = assertThrows(
@@ -1440,8 +1396,7 @@ public void testGetDirectoryModificationTime()
FileStatus[] fileStatuses = o3fs.listStatus(mdir11);
// Above listStatus result should only have one entry: mdir111
assertEquals(1, fileStatuses.length);
- assertEquals(mdir111.toString(),
- fileStatuses[0].getPath().toUri().getPath());
+ assertEquals(mdir111.toString(), fileStatuses[0].getPath().toUri().getPath());
assertTrue(fileStatuses[0].isDirectory());
// The dir key is actually created on server,
// so modification time should always be the same value.
@@ -1457,8 +1412,7 @@ public void testGetDirectoryModificationTime()
fileStatuses = o3fs.listStatus(mdir1);
// Above listStatus result should only have one entry: mdir11
assertEquals(1, fileStatuses.length);
- assertEquals(mdir11.toString(),
- fileStatuses[0].getPath().toUri().getPath());
+ assertEquals(mdir11.toString(), fileStatuses[0].getPath().toUri().getPath());
assertTrue(fileStatuses[0].isDirectory());
// Since the dir key doesn't exist on server, the modification time is
// set to current time upon every listStatus request.
@@ -1496,7 +1450,7 @@ public void testCreateKeyShouldUseRefreshedBucketReplicationConfig()
// Set the fs.defaultFS and start the filesystem
Configuration conf = new OzoneConfiguration(cluster.getConf());
- conf.set(CommonConfigurationKeysPublic.FS_DEFAULT_NAME_KEY, rootPath);
+ conf.set(FS_DEFAULT_NAME_KEY, rootPath);
// Set the number of keys to be processed during batch operate.
OzoneFileSystem o3FS = (OzoneFileSystem) FileSystem.get(conf);
@@ -1538,9 +1492,8 @@ private void createKeyAndAssertKeyType(OzoneBucket bucket,
OzoneFileSystem o3FS, Path keyPath, ReplicationType expectedType)
throws IOException {
o3FS.createFile(keyPath).build().close();
- assertEquals(expectedType.name(),
- bucket.getKey(o3FS.pathToKey(keyPath)).getReplicationConfig()
- .getReplicationType().name());
+ assertEquals(expectedType.name(), bucket.getKey(o3FS.pathToKey(keyPath)).getReplicationConfig()
+ .getReplicationType().name());
}
@Test
@@ -1554,8 +1507,7 @@ public void testGetTrashRoots() throws IOException {
fs.mkdirs(userTrash);
res = o3fs.getTrashRoots(false);
assertEquals(1, res.size());
- res.forEach(e -> assertEquals(
- userTrash.toString(), e.getPath().toUri().getPath()));
+ res.forEach(e -> assertEquals(userTrash.toString(), e.getPath().toUri().getPath()));
// Only have one user trash for now
res = o3fs.getTrashRoots(true);
assertEquals(1, res.size());
@@ -1572,8 +1524,7 @@ public void testGetTrashRoots() throws IOException {
// allUsers = false should still return current user trash
res = o3fs.getTrashRoots(false);
assertEquals(1, res.size());
- res.forEach(e -> assertEquals(
- userTrash.toString(), e.getPath().toUri().getPath()));
+ res.forEach(e -> assertEquals(userTrash.toString(), e.getPath().toUri().getPath()));
// allUsers = true should return all user trash
res = o3fs.getTrashRoots(true);
assertEquals(6, res.size());
@@ -1663,8 +1614,7 @@ public void testListStatusOnLargeDirectoryForACLCheck() throws Exception {
cluster.getOzoneManager().getKeyManager());
fail("Non-existent key name!");
} catch (OMException ome) {
- assertEquals(OMException.ResultCodes.KEY_NOT_FOUND,
- ome.getResult());
+ assertEquals(OMException.ResultCodes.KEY_NOT_FOUND, ome.getResult());
}
OzonePrefixPathImpl ozonePrefixPath =
@@ -1678,7 +1628,7 @@ public void testListStatusOnLargeDirectoryForACLCheck() throws Exception {
Iterator pathItr =
ozonePrefixPath.getChildren(keyName);
- assertTrue("Failed to list keyPath:" + keyName, pathItr.hasNext());
+ assertTrue(pathItr.hasNext(), "Failed to list keyPath:" + keyName);
Set actualPaths = new TreeSet<>();
while (pathItr.hasNext()) {
@@ -1689,17 +1639,15 @@ public void testListStatusOnLargeDirectoryForACLCheck() throws Exception {
Iterator subPathItr =
ozonePrefixPath.getChildren(pathname);
assertNotNull(subPathItr);
- assertFalse("Failed to list keyPath: " + pathname,
- subPathItr.hasNext());
+ assertFalse(subPathItr.hasNext(), "Failed to list keyPath: " + pathname);
}
- assertEquals("ListStatus failed", paths.size(),
- actualPaths.size());
+ assertEquals(paths.size(), actualPaths.size(), "ListStatus failed");
for (String pathname : actualPaths) {
paths.remove(pathname);
}
- assertTrue("ListStatus failed:" + paths, paths.isEmpty());
+ assertTrue(paths.isEmpty(), "ListStatus failed:" + paths);
}
@Test
@@ -1760,8 +1708,7 @@ public void testLoopInLinkBuckets() throws Exception {
fail("Should throw Exception due to loop in Link Buckets");
} catch (OMException oe) {
// Expected exception
- assertEquals(OMException.ResultCodes.DETECTED_LOOP_IN_BUCKET_LINKS,
- oe.getResult());
+ assertEquals(OMException.ResultCodes.DETECTED_LOOP_IN_BUCKET_LINKS, oe.getResult());
} finally {
volume.deleteBucket(linkBucket1Name);
volume.deleteBucket(linkBucket2Name);
@@ -1831,4 +1778,391 @@ public void testProcessingDetails() throws IOException, InterruptedException {
GenericTestUtils.setLogLevel(log, Level.INFO);
assertNotEquals(nonZeroLines, 0);
}
+
+ @Test
+ public void testOzFsReadWrite() throws IOException {
+ assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
+
+ long currentTime = Time.now();
+ int stringLen = 20;
+ OMMetadataManager metadataManager = cluster.getOzoneManager()
+ .getMetadataManager();
+ String lev1dir = "l1dir";
+ Path lev1path = createPath("/" + lev1dir);
+ String lev1key = metadataManager.getOzoneDirKey(volumeName, bucketName,
+ o3fs.pathToKey(lev1path));
+ String lev2dir = "l2dir";
+ Path lev2path = createPath("/" + lev1dir + "/" + lev2dir);
+ String lev2key = metadataManager.getOzoneDirKey(volumeName, bucketName,
+ o3fs.pathToKey(lev2path));
+
+ String data = RandomStringUtils.randomAlphanumeric(stringLen);
+ String filePath = RandomStringUtils.randomAlphanumeric(5);
+
+ Path path = createPath("/" + lev1dir + "/" + lev2dir + "/" + filePath);
+ String fileKey = metadataManager.getOzoneDirKey(volumeName, bucketName,
+ o3fs.pathToKey(path));
+
+ // verify prefix directories and the file, do not already exist
+ assertNull(metadataManager.getKeyTable(getBucketLayout()).get(lev1key));
+ assertNull(metadataManager.getKeyTable(getBucketLayout()).get(lev2key));
+ assertNull(metadataManager.getKeyTable(getBucketLayout()).get(fileKey));
+
+ Map statsBefore = statistics.snapshot();
+ try (FSDataOutputStream stream = fs.create(path)) {
+ stream.writeBytes(data);
+ }
+
+ assertChange(statsBefore, statistics, OP_CREATE, 1);
+ assertChange(statsBefore, statistics, "objects_created", 1);
+
+ FileStatus status = fs.getFileStatus(path);
+
+ assertChange(statsBefore, statistics, OP_GET_FILE_STATUS, 1);
+ assertChange(statsBefore, statistics, "objects_query", 1);
+
+ // The timestamp of the newly created file should always be greater than
+ // the time when the test was started
+ assertTrue(status.getModificationTime() > currentTime);
+
+ assertFalse(status.isDirectory());
+ assertEquals(FsPermission.getFileDefault(), status.getPermission());
+ verifyOwnerGroup(status);
+
+ // verify prefix directories got created when creating the file.
+ assertEquals("l1dir/", metadataManager.getKeyTable(getBucketLayout()).get(lev1key).getKeyName());
+ assertEquals("l1dir/l2dir/", metadataManager.getKeyTable(getBucketLayout()).get(lev2key).getKeyName());
+ FileStatus lev1status = getDirectoryStat(lev1path);
+ assertNotNull(lev1status);
+ FileStatus lev2status = getDirectoryStat(lev2path);
+ assertNotNull(lev2status);
+
+ try (FSDataInputStream inputStream = fs.open(path)) {
+ byte[] buffer = new byte[stringLen];
+ // This read will not change the offset inside the file
+ int readBytes = inputStream.read(0, buffer, 0, buffer.length);
+ String out = new String(buffer, 0, buffer.length, UTF_8);
+ assertEquals(data, out);
+ assertEquals(readBytes, buffer.length);
+ assertEquals(0, inputStream.getPos());
+
+ // The following read will change the internal offset
+ readBytes = inputStream.read(buffer, 0, buffer.length);
+ assertEquals(data, out);
+ assertEquals(readBytes, buffer.length);
+ assertEquals(buffer.length, inputStream.getPos());
+ }
+
+ assertChange(statsBefore, statistics, OP_OPEN, 1);
+ assertChange(statsBefore, statistics, "objects_read", 1);
+ }
+
+ private static void assertChange(Map before, OzoneFSStorageStatistics after, String key, long delta) {
+ assertEquals(before.get(key) + delta, after.getLong(key));
+ }
+
+ @Test
+ public void testReplication() throws IOException {
+ assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
+
+ int stringLen = 20;
+ String data = RandomStringUtils.randomAlphanumeric(stringLen);
+ String filePath = RandomStringUtils.randomAlphanumeric(5);
+
+ Path pathIllegal = createPath("/" + filePath + "illegal");
+ try (FSDataOutputStream streamIllegal = fs.create(pathIllegal, (short)2)) {
+ streamIllegal.writeBytes(data);
+ }
+ assertEquals(3, fs.getFileStatus(pathIllegal).getReplication());
+
+ Path pathLegal = createPath("/" + filePath + "legal");
+ try (FSDataOutputStream streamLegal = fs.create(pathLegal, (short)1)) {
+ streamLegal.writeBytes(data);
+ }
+ assertEquals(1, fs.getFileStatus(pathLegal).getReplication());
+ }
+
+ private void verifyOwnerGroup(FileStatus fileStatus) {
+ String owner = getCurrentUser();
+ assertEquals(owner, fileStatus.getOwner());
+ assertEquals(owner, fileStatus.getGroup());
+ }
+
+
+ @Test
+ public void testDirectory() throws IOException {
+ assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
+
+ String leafName = RandomStringUtils.randomAlphanumeric(5);
+ OMMetadataManager metadataManager = cluster.getOzoneManager()
+ .getMetadataManager();
+
+ String lev1dir = "abc";
+ Path lev1path = createPath("/" + lev1dir);
+ String lev1key = metadataManager.getOzoneDirKey(volumeName, bucketName,
+ o3fs.pathToKey(lev1path));
+ String lev2dir = "def";
+ Path lev2path = createPath("/" + lev1dir + "/" + lev2dir);
+ String lev2key = metadataManager.getOzoneDirKey(volumeName, bucketName,
+ o3fs.pathToKey(lev2path));
+
+ Path leaf = createPath("/" + lev1dir + "/" + lev2dir + "/" + leafName);
+ String leafKey = metadataManager.getOzoneDirKey(volumeName, bucketName,
+ o3fs.pathToKey(leaf));
+
+ // verify prefix directories and the leaf, do not already exist
+ assertNull(metadataManager.getKeyTable(getBucketLayout()).get(lev1key));
+ assertNull(metadataManager.getKeyTable(getBucketLayout()).get(lev2key));
+ assertNull(metadataManager.getKeyTable(getBucketLayout()).get(leafKey));
+
+ assertTrue(fs.mkdirs(leaf));
+
+ // verify the leaf directory got created.
+ FileStatus leafstatus = getDirectoryStat(leaf);
+ assertNotNull(leafstatus);
+
+ // verify prefix directories got created when creating the leaf directory.
+ assertEquals("abc/", metadataManager
+ .getKeyTable(getBucketLayout())
+ .get(lev1key)
+ .getKeyName());
+ assertEquals("abc/def/", metadataManager
+ .getKeyTable(getBucketLayout())
+ .get(lev2key)
+ .getKeyName());
+ FileStatus lev1status = getDirectoryStat(lev1path);
+ assertNotNull(lev1status);
+ FileStatus lev2status = getDirectoryStat(lev2path);
+ assertNotNull(lev2status);
+
+ // check the root directory
+ FileStatus rootStatus = getDirectoryStat(createPath("/"));
+ assertNotNull(rootStatus);
+
+ // root directory listing should contain the lev1 prefix directory
+ FileStatus[] statusList = fs.listStatus(createPath("/"));
+ assertEquals(1, statusList.length);
+ assertEquals(lev1status, statusList[0]);
+ }
+
+ @Test
+ void testListStatus2() throws IOException {
+ List paths = new ArrayList<>();
+ String dirPath = RandomStringUtils.randomAlphanumeric(5);
+ Path path = createPath("/" + dirPath);
+ paths.add(path);
+
+ final Map initialStats = statistics.snapshot();
+ assertTrue(fs.mkdirs(path));
+ assertChange(initialStats, statistics, OP_MKDIRS, 1);
+
+ final long initialListStatusCount = omMetrics.getNumListStatus();
+ FileStatus[] statusList = fs.listStatus(createPath("/"));
+ assertEquals(1, statusList.length);
+ assertChange(initialStats, statistics, Statistic.OBJECTS_LIST.getSymbol(), 1);
+ assertEquals(initialListStatusCount + 1, omMetrics.getNumListStatus());
+ assertEquals(fs.getFileStatus(path), statusList[0]);
+
+ dirPath = RandomStringUtils.randomAlphanumeric(5);
+ path = createPath("/" + dirPath);
+ paths.add(path);
+ assertTrue(fs.mkdirs(path));
+ assertChange(initialStats, statistics, OP_MKDIRS, 2);
+
+ statusList = fs.listStatus(createPath("/"));
+ assertEquals(2, statusList.length);
+ assertChange(initialStats, statistics, Statistic.OBJECTS_LIST.getSymbol(), 2);
+ assertEquals(initialListStatusCount + 2, omMetrics.getNumListStatus());
+ for (Path p : paths) {
+ assertTrue(Arrays.asList(statusList).contains(fs.getFileStatus(p)));
+ }
+ }
+
+ @Test
+ void testOzoneManagerFileSystemInterface() throws IOException {
+ String dirPath = RandomStringUtils.randomAlphanumeric(5);
+
+ Path path = createPath("/" + dirPath);
+ assertTrue(fs.mkdirs(path));
+
+ long numFileStatus =
+ cluster.getOzoneManager().getMetrics().getNumGetFileStatus();
+ FileStatus status = fs.getFileStatus(path);
+
+ assertEquals(numFileStatus + 1,
+ cluster.getOzoneManager().getMetrics().getNumGetFileStatus());
+ assertTrue(status.isDirectory());
+ assertEquals(FsPermission.getDirDefault(), status.getPermission());
+ verifyOwnerGroup(status);
+
+ long currentTime = System.currentTimeMillis();
+ OmKeyArgs keyArgs = new OmKeyArgs.Builder()
+ .setVolumeName(volumeName)
+ .setBucketName(bucketName)
+ .setKeyName(o3fs.pathToKey(path))
+ .build();
+ OzoneFileStatus omStatus =
+ cluster.getOzoneManager().getFileStatus(keyArgs);
+ //Another get file status here, incremented the counter.
+ assertEquals(numFileStatus + 2,
+ cluster.getOzoneManager().getMetrics().getNumGetFileStatus());
+ assertTrue(omStatus.isDirectory());
+
+ // For directories, the time returned is the current time when the dir key
+ // doesn't actually exist on server; if it exists, it will be a fixed value.
+ // In this case, the dir key exists.
+ assertEquals(0, omStatus.getKeyInfo().getDataSize());
+ assertTrue(omStatus.getKeyInfo().getModificationTime() <= currentTime);
+ assertEquals(new Path(omStatus.getPath()).getName(),
+ o3fs.pathToKey(path));
+ }
+
+ @Test
+ public void testOzoneManagerLocatedFileStatus() throws IOException {
+ String data = RandomStringUtils.randomAlphanumeric(20);
+ String filePath = RandomStringUtils.randomAlphanumeric(5);
+ Path path = createPath("/" + filePath);
+ try (FSDataOutputStream stream = fs.create(path)) {
+ stream.writeBytes(data);
+ }
+ FileStatus status = fs.getFileStatus(path);
+ assertTrue(status instanceof LocatedFileStatus);
+ LocatedFileStatus locatedFileStatus = (LocatedFileStatus) status;
+ assertTrue(locatedFileStatus.getBlockLocations().length >= 1);
+
+ for (BlockLocation blockLocation : locatedFileStatus.getBlockLocations()) {
+ assertTrue(blockLocation.getNames().length >= 1);
+ assertTrue(blockLocation.getHosts().length >= 1);
+ }
+ }
+
+ @Test
+ void testBlockOffsetsWithMultiBlockFile() throws Exception {
+ // naive assumption: MiniOzoneCluster will not have larger than ~1GB
+ // block size when running this test.
+ int blockSize = (int) fs.getConf().getStorageSize(
+ OzoneConfigKeys.OZONE_SCM_BLOCK_SIZE,
+ OzoneConfigKeys.OZONE_SCM_BLOCK_SIZE_DEFAULT,
+ StorageUnit.BYTES
+ );
+ String data = RandomStringUtils.randomAlphanumeric(2 * blockSize + 837);
+ String filePath = RandomStringUtils.randomAlphanumeric(5);
+ Path path = createPath("/" + filePath);
+ try (FSDataOutputStream stream = fs.create(path)) {
+ stream.writeBytes(data);
+ }
+ FileStatus status = fs.getFileStatus(path);
+ assertTrue(status instanceof LocatedFileStatus);
+ LocatedFileStatus locatedFileStatus = (LocatedFileStatus) status;
+ BlockLocation[] blockLocations = locatedFileStatus.getBlockLocations();
+
+ assertEquals(0, blockLocations[0].getOffset());
+ assertEquals(blockSize, blockLocations[1].getOffset());
+ assertEquals(2 * blockSize, blockLocations[2].getOffset());
+ assertEquals(blockSize, blockLocations[0].getLength());
+ assertEquals(blockSize, blockLocations[1].getLength());
+ assertEquals(837, blockLocations[2].getLength());
+ }
+
+ @Test
+ void testPathToKey() {
+ assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
+
+ assertEquals("a/b/1", o3fs.pathToKey(new Path("/a/b/1")));
+
+ assertEquals("user/" + getCurrentUser() + "/key1/key2",
+ o3fs.pathToKey(new Path("key1/key2")));
+
+ assertEquals("key1/key2",
+ o3fs.pathToKey(new Path("o3fs://test1/key1/key2")));
+ }
+
+
+ /**
+ * Verify that FS throws exception when trying to access bucket with
+ * incompatible layout.
+ */
+ @Test
+ void testFileSystemWithObjectStoreLayout() throws IOException {
+ String obsVolume = UUID.randomUUID().toString();
+
+ try (OzoneClient client = cluster.newClient()) {
+ ObjectStore store = client.getObjectStore();
+
+ // Create volume and bucket
+ store.createVolume(obsVolume);
+ OzoneVolume volume = store.getVolume(obsVolume);
+ String obsBucket = UUID.randomUUID().toString();
+ // create bucket with OBJECT_STORE bucket layout (incompatible with fs)
+ volume.createBucket(obsBucket, BucketArgs.newBuilder()
+ .setBucketLayout(BucketLayout.OBJECT_STORE)
+ .build());
+
+ String obsRootPath = String.format("%s://%s.%s/",
+ OzoneConsts.OZONE_URI_SCHEME, obsBucket, obsVolume);
+
+ OzoneConfiguration config = new OzoneConfiguration(fs.getConf());
+ config.set(FS_DEFAULT_NAME_KEY, obsRootPath);
+
+ IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> FileSystem.get(config));
+ assertTrue(e.getMessage().contains("OBJECT_STORE, which does not support file system semantics"));
+ }
+ }
+
+ private String getCurrentUser() {
+ try {
+ return UserGroupInformation.getCurrentUser().getShortUserName();
+ } catch (IOException e) {
+ return OZONE_DEFAULT_USER;
+ }
+ }
+
+ private Path createPath(String relativePath) {
+ if (enabledFileSystemPaths) {
+ return new Path(fsRoot + (relativePath.startsWith("/") ? "" : "/") + relativePath);
+ } else {
+ return new Path(relativePath);
+ }
+ }
+
+ /**
+ * verify that a directory exists and is initialized correctly.
+ * @param path of the directory
+ * @return null indicates FILE_NOT_FOUND, else the FileStatus
+ */
+ private FileStatus getDirectoryStat(Path path) throws IOException {
+ FileStatus status = fs.getFileStatus(path);
+ assertTrue(status.isDirectory());
+ assertEquals(FsPermission.getDirDefault(), status.getPermission());
+ verifyOwnerGroup(status);
+ assertEquals(0, status.getLen());
+ return status;
+ }
+
+ private void assertCounter(long value, String key) {
+ assertEquals(value, statistics.getLong(key).longValue());
+ }
+
+ @Test
+ void testSnapshotRead() throws Exception {
+ // Init data
+ Path snapPath1 = fs.createSnapshot(new Path("/"), "snap1");
+
+ Path file1 = new Path("/key1");
+ Path file2 = new Path("/key2");
+ ContractTestUtils.touch(fs, file1);
+ ContractTestUtils.touch(fs, file2);
+ Path snapPath2 = fs.createSnapshot(new Path("/"), "snap2");
+
+ Path file3 = new Path("/key3");
+ ContractTestUtils.touch(fs, file3);
+ Path snapPath3 = fs.createSnapshot(new Path("/"), "snap3");
+
+ FileStatus[] f1 = fs.listStatus(snapPath1);
+ FileStatus[] f2 = fs.listStatus(snapPath2);
+ FileStatus[] f3 = fs.listStatus(snapPath3);
+ assertEquals(0, f1.length);
+ assertEquals(2, f2.length);
+ assertEquals(3, f3.length);
+ }
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithFSO.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTestWithFSO.java
similarity index 80%
rename from hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithFSO.java
rename to hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTestWithFSO.java
index d2d2fd6b816c..cdb7d0cc16e9 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithFSO.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTestWithFSO.java
@@ -33,61 +33,41 @@
import org.apache.hadoop.ozone.om.helpers.OmDirectoryInfo;
import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
import org.apache.ozone.test.GenericTestUtils;
-import org.junit.After;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestMethodOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
/**
* Ozone file system tests that are not covered by contract tests,
* - prefix layout.
*
*/
-@RunWith(Parameterized.class)
-public class TestOzoneFileSystemWithFSO extends TestOzoneFileSystem {
-
- @Parameterized.Parameters
- public static Collection data() {
- return Arrays.asList(
- new Object[]{true, true},
- new Object[]{true, false});
- }
-
- @BeforeClass
- public static void init() {
- setBucketLayout(BucketLayout.FILE_SYSTEM_OPTIMIZED);
- }
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+abstract class AbstractOzoneFileSystemTestWithFSO extends AbstractOzoneFileSystemTest {
- public TestOzoneFileSystemWithFSO(boolean setDefaultFs,
- boolean enableOMRatis) {
- super(setDefaultFs, enableOMRatis);
- }
+ private static final Logger LOG =
+ LoggerFactory.getLogger(AbstractOzoneFileSystemTestWithFSO.class);
- @After
- @Override
- public void cleanup() {
- super.cleanup();
+ AbstractOzoneFileSystemTestWithFSO(boolean enableOMRatis) {
+ super(true, enableOMRatis, BucketLayout.FILE_SYSTEM_OPTIMIZED);
}
- private static final Logger LOG =
- LoggerFactory.getLogger(TestOzoneFileSystemWithFSO.class);
-
@Test
public void testListStatusWithoutRecursiveSearch() throws Exception {
/*
@@ -102,32 +82,27 @@ public void testListStatusWithoutRecursiveSearch() throws Exception {
Path key1 = new Path("/key1");
try (FSDataOutputStream outputStream = getFs().create(key1,
false)) {
- assertNotNull("Should be able to create file: key1",
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: key1");
}
Path d1 = new Path("/d1");
Path dir1Key1 = new Path(d1, "key1");
try (FSDataOutputStream outputStream = getFs().create(dir1Key1, false)) {
- assertNotNull("Should be able to create file: " + dir1Key1,
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: " + dir1Key1);
}
Path d2 = new Path("/d2");
Path dir2Key1 = new Path(d2, "key1");
try (FSDataOutputStream outputStream = getFs().create(dir2Key1, false)) {
- assertNotNull("Should be able to create file: " + dir2Key1,
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: " + dir2Key1);
}
Path dir1Dir2 = new Path("/d1/d2/");
Path dir1Dir2Key1 = new Path(dir1Dir2, "key1");
try (FSDataOutputStream outputStream = getFs().create(dir1Dir2Key1,
false)) {
- assertNotNull("Should be able to create file: " + dir1Dir2Key1,
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: " + dir1Dir2Key1);
}
Path d1Key2 = new Path(d1, "key2");
try (FSDataOutputStream outputStream = getFs().create(d1Key2, false)) {
- assertNotNull("Should be able to create file: " + d1Key2,
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: " + d1Key2);
}
Path dir1Dir3 = new Path("/d1/d3/");
@@ -141,8 +116,7 @@ public void testListStatusWithoutRecursiveSearch() throws Exception {
// Root Directory
FileStatus[] fileStatusList = getFs().listStatus(new Path("/"));
- assertEquals("FileStatus should return files and directories",
- 3, fileStatusList.length);
+ assertEquals(3, fileStatusList.length, "FileStatus should return files and directories");
ArrayList expectedPaths = new ArrayList<>();
expectedPaths.add("o3fs://" + bucketName + "." + volumeName + "/d1");
expectedPaths.add("o3fs://" + bucketName + "." + volumeName + "/d2");
@@ -150,13 +124,11 @@ public void testListStatusWithoutRecursiveSearch() throws Exception {
for (FileStatus fileStatus : fileStatusList) {
expectedPaths.remove(fileStatus.getPath().toString());
}
- assertEquals("Failed to return the filestatus[]" + expectedPaths,
- 0, expectedPaths.size());
+ assertEquals(0, expectedPaths.size(), "Failed to return the filestatus[]" + expectedPaths);
// level-1 sub-dirs
fileStatusList = getFs().listStatus(new Path("/d1"));
- assertEquals("FileStatus should return files and directories",
- 5, fileStatusList.length);
+ assertEquals(5, fileStatusList.length, "FileStatus should return files and directories");
expectedPaths = new ArrayList<>();
expectedPaths.add("o3fs://" + bucketName + "." + volumeName + "/d1/d2");
expectedPaths.add("o3fs://" + bucketName + "." + volumeName + "/d1/d3");
@@ -166,34 +138,29 @@ public void testListStatusWithoutRecursiveSearch() throws Exception {
for (FileStatus fileStatus : fileStatusList) {
expectedPaths.remove(fileStatus.getPath().toString());
}
- assertEquals("Failed to return the filestatus[]" + expectedPaths,
- 0, expectedPaths.size());
+ assertEquals(0, expectedPaths.size(), "Failed to return the filestatus[]" + expectedPaths);
// level-2 sub-dirs
fileStatusList = getFs().listStatus(new Path("/d1/d2"));
- assertEquals("FileStatus should return files and directories",
- 1, fileStatusList.length);
+ assertEquals(1, fileStatusList.length, "FileStatus should return files and directories");
expectedPaths = new ArrayList<>();
expectedPaths.add("o3fs://" + bucketName + "." + volumeName + "/d1/d2/" +
"key1");
for (FileStatus fileStatus : fileStatusList) {
expectedPaths.remove(fileStatus.getPath().toString());
}
- assertEquals("Failed to return the filestatus[]" + expectedPaths,
- 0, expectedPaths.size());
+ assertEquals(0, expectedPaths.size(), "Failed to return the filestatus[]" + expectedPaths);
// level-2 key2
fileStatusList = getFs().listStatus(new Path("/d1/d2/key1"));
- assertEquals("FileStatus should return files and directories",
- 1, fileStatusList.length);
+ assertEquals(1, fileStatusList.length, "FileStatus should return files and directories");
expectedPaths = new ArrayList<>();
expectedPaths.add("o3fs://" + bucketName + "." + volumeName + "/d1/d2/" +
"key1");
for (FileStatus fileStatus : fileStatusList) {
expectedPaths.remove(fileStatus.getPath().toString());
}
- assertEquals("Failed to return the filestatus[]" + expectedPaths,
- 0, expectedPaths.size());
+ assertEquals(0, expectedPaths.size(), "Failed to return the filestatus[]" + expectedPaths);
// invalid root key
try {
@@ -222,24 +189,21 @@ public void testListFilesRecursive() throws Exception {
Path dir1Dir1Dir2Key1 = new Path("/d1/d1/d2/key1");
try (FSDataOutputStream outputStream = getFs().create(dir1Dir1Dir2Key1,
false)) {
- assertNotNull("Should be able to create file: " + dir1Dir1Dir2Key1,
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: " + dir1Dir1Dir2Key1);
}
Path key1 = new Path("/key1");
try (FSDataOutputStream outputStream = getFs().create(key1, false)) {
- assertNotNull("Should be able to create file: " + key1,
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: " + key1);
}
Path key2 = new Path("/key2");
try (FSDataOutputStream outputStream = getFs().create(key2, false)) {
- assertNotNull("Should be able to create file: key2",
- outputStream);
+ assertNotNull(outputStream, "Should be able to create file: key2");
}
Path dir1Dir2Dir1Dir2Key1 = new Path("/d1/d2/d1/d2/key1");
try (FSDataOutputStream outputStream = getFs().create(dir1Dir2Dir1Dir2Key1,
false)) {
- assertNotNull("Should be able to create file: "
- + dir1Dir2Dir1Dir2Key1, outputStream);
+ assertNotNull(outputStream, "Should be able to create file: "
+ + dir1Dir2Dir1Dir2Key1);
}
RemoteIterator fileStatusItr = getFs().listFiles(
new Path("/"), true);
@@ -256,10 +220,8 @@ public void testListFilesRecursive() throws Exception {
expectedPaths.remove(status.getPath().toString());
actualCount++;
}
- assertEquals("Failed to get all the files: " + expectedPaths,
- expectedFilesCount, actualCount);
- assertEquals("Failed to get all the files: " + expectedPaths, 0,
- expectedPaths.size());
+ assertEquals(expectedFilesCount, actualCount, "Failed to get all the files: " + expectedPaths);
+ assertEquals(0, expectedPaths.size(), "Failed to get all the files: " + expectedPaths);
// Recursive=false
fileStatusItr = getFs().listFiles(new Path("/"), false);
@@ -273,10 +235,8 @@ public void testListFilesRecursive() throws Exception {
expectedPaths.remove(status.getPath().toString());
actualCount++;
}
- assertEquals("Failed to get all the files: " + expectedPaths, 0,
- expectedPaths.size());
- assertEquals("Failed to get all the files: " + expectedPaths,
- expectedFilesCount, actualCount);
+ assertEquals(0, expectedPaths.size(), "Failed to get all the files: " + expectedPaths);
+ assertEquals(expectedFilesCount, actualCount, "Failed to get all the files: " + expectedPaths);
}
/**
@@ -431,8 +391,7 @@ public void testMultiLevelDirs() throws Exception {
// reset metrics
long numKeys = getCluster().getOzoneManager().getMetrics().getNumKeys();
getCluster().getOzoneManager().getMetrics().decNumKeys(numKeys);
- assertEquals(0,
- getCluster().getOzoneManager().getMetrics().getNumKeys());
+ assertEquals(0, getCluster().getOzoneManager().getMetrics().getNumKeys());
// Op 1. create dir -> /d1/d2/d3/d4/
// Op 2. create dir -> /d1/d2/d3/d4/d5
@@ -444,7 +403,7 @@ public void testMultiLevelDirs() throws Exception {
getCluster().getOzoneManager().getMetadataManager();
OmBucketInfo omBucketInfo = omMgr.getBucketTable()
.get(omMgr.getBucketKey(getVolumeName(), getBucketName()));
- assertNotNull("Failed to find bucketInfo", omBucketInfo);
+ assertNotNull(omBucketInfo, "Failed to find bucketInfo");
final long volumeId = omMgr.getVolumeId(getVolumeName());
final long bucketId = omMgr.getBucketId(getVolumeName(), getBucketName());
@@ -462,8 +421,7 @@ public void testMultiLevelDirs() throws Exception {
verifyDirKey(volumeId, bucketId, d3ObjectID,
"d4", "/d1/d2/d3/d4", dirKeys, omMgr);
- assertEquals("Wrong OM numKeys metrics", 4,
- getCluster().getOzoneManager().getMetrics().getNumKeys());
+ assertEquals(4, getCluster().getOzoneManager().getMetrics().getNumKeys(), "Wrong OM numKeys metrics");
// create sub-dirs under same parent
Path subDir5 = new Path("/d1/d2/d3/d4/d5");
@@ -476,15 +434,14 @@ public void testMultiLevelDirs() throws Exception {
long d6ObjectID =
verifyDirKey(volumeId, bucketId, d4ObjectID,
"d6", "/d1/d2/d3/d4/d6", dirKeys, omMgr);
- assertTrue(
- "Wrong objectIds for sub-dirs[" + d5ObjectID + "/d5, " + d6ObjectID
- + "/d6] of same parent!", d5ObjectID != d6ObjectID);
+ assertTrue(d5ObjectID != d6ObjectID, "Wrong objectIds for sub-dirs[" + d5ObjectID + "/d5, " + d6ObjectID
+ + "/d6] of same parent!");
- assertEquals("Wrong OM numKeys metrics", 6,
- getCluster().getOzoneManager().getMetrics().getNumKeys());
+ assertEquals(6, getCluster().getOzoneManager().getMetrics().getNumKeys(), "Wrong OM numKeys metrics");
}
@Test
+ @Order(1)
public void testCreateFile() throws Exception {
// Op 1. create dir -> /d1/d2/d3/d4/
Path parent = new Path("/d1/d2/");
@@ -496,7 +453,7 @@ public void testCreateFile() throws Exception {
getCluster().getOzoneManager().getMetadataManager();
OmBucketInfo omBucketInfo = omMgr.getBucketTable()
.get(omMgr.getBucketKey(getVolumeName(), getBucketName()));
- assertNotNull("Failed to find bucketInfo", omBucketInfo);
+ assertNotNull(omBucketInfo, "Failed to find bucketInfo");
ArrayList dirKeys = new ArrayList<>();
@@ -516,7 +473,7 @@ public void testCreateFile() throws Exception {
outputStream.close();
OmKeyInfo omKeyInfo = omMgr.getKeyTable(getBucketLayout()).get(openFileKey);
- assertNotNull("Invalid Key!", omKeyInfo);
+ assertNotNull(omKeyInfo, "Invalid Key!");
verifyOMFileInfoFormat(omKeyInfo, file.getName(), d2ObjectID);
// wait for DB updates
@@ -538,7 +495,7 @@ public void testCreateFile() throws Exception {
@Test
public void testLeaseRecoverable() throws Exception {
// Create a file
- Path parent = new Path("/d1/d2/");
+ Path parent = new Path("/d1");
Path source = new Path(parent, "file1");
LeaseRecoverable fs = (LeaseRecoverable)getFs();
@@ -571,11 +528,10 @@ public void testFSDeleteLogWarnNoExist() throws Exception {
private void verifyOMFileInfoFormat(OmKeyInfo omKeyInfo, String fileName,
long parentID) {
- assertEquals("Wrong keyName", fileName, omKeyInfo.getKeyName());
- assertEquals("Wrong parentID", parentID,
- omKeyInfo.getParentObjectID());
+ assertEquals(fileName, omKeyInfo.getKeyName(), "Wrong keyName");
+ assertEquals(parentID, omKeyInfo.getParentObjectID(), "Wrong parentID");
String dbKey = parentID + OzoneConsts.OM_KEY_PREFIX + fileName;
- assertEquals("Wrong path format", dbKey, omKeyInfo.getPath());
+ assertEquals(dbKey, omKeyInfo.getPath(), "Wrong path format");
}
long verifyDirKey(long volumeId, long bucketId, long parentId,
@@ -586,21 +542,13 @@ long verifyDirKey(long volumeId, long bucketId, long parentId,
parentId + "/" + dirKey;
dirKeys.add(dbKey);
OmDirectoryInfo dirInfo = omMgr.getDirectoryTable().get(dbKey);
- assertNotNull("Failed to find " + absolutePath +
- " using dbKey: " + dbKey, dirInfo);
- assertEquals("Parent Id mismatches", parentId,
- dirInfo.getParentObjectID());
- assertEquals("Mismatches directory name", dirKey,
- dirInfo.getName());
- assertTrue("Mismatches directory creation time param",
- dirInfo.getCreationTime() > 0);
- assertEquals("Mismatches directory modification time param",
- dirInfo.getCreationTime(), dirInfo.getModificationTime());
+ assertNotNull(dirInfo, "Failed to find " + absolutePath +
+ " using dbKey: " + dbKey);
+ assertEquals(parentId, dirInfo.getParentObjectID(), "Parent Id mismatches");
+ assertEquals(dirKey, dirInfo.getName(), "Mismatches directory name");
+ assertTrue(dirInfo.getCreationTime() > 0, "Mismatches directory creation time param");
+ assertEquals(dirInfo.getCreationTime(), dirInfo.getModificationTime());
return dirInfo.getObjectID();
}
- @Override
- public BucketLayout getBucketLayout() {
- return BucketLayout.FILE_SYSTEM_OPTIMIZED;
- }
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileInterfacesWithFSO.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FS.java
similarity index 54%
rename from hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileInterfacesWithFSO.java
rename to hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FS.java
index 5a0dc6ef5a2f..5fdab6fe95da 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileInterfacesWithFSO.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FS.java
@@ -6,39 +6,23 @@
* 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
- *
+ *
+ * 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.fs.ozone;
import org.apache.hadoop.ozone.om.helpers.BucketLayout;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-/**
- * Test OzoneFileSystem Interfaces - prefix layout.
- *
- * This test will test the various interfaces i.e.
- * create, read, write, getFileStatus
- */
-@RunWith(Parameterized.class)
-public class TestOzoneFileInterfacesWithFSO extends TestOzoneFileInterfaces {
-
- public TestOzoneFileInterfacesWithFSO(boolean setDefaultFs,
- boolean useAbsolutePath, boolean enabledFileSystemPaths)
- throws Exception {
- super(setDefaultFs, useAbsolutePath, enabledFileSystemPaths);
- }
+import org.junit.jupiter.api.TestInstance;
- @Override
- public BucketLayout getBucketLayout() {
- return BucketLayout.FILE_SYSTEM_OPTIMIZED;
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestO3FS extends AbstractOzoneFileSystemTest {
+ TestO3FS() {
+ super(false, false, BucketLayout.LEGACY);
}
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSO.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSO.java
new file mode 100644
index 000000000000..0d6be62b4fc4
--- /dev/null
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSO.java
@@ -0,0 +1,27 @@
+/*
+ * 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.fs.ozone;
+
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestO3FSWithFSO extends AbstractOzoneFileSystemTestWithFSO {
+ TestO3FSWithFSO() {
+ super(false);
+ }
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSOAndOMRatis.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSOAndOMRatis.java
new file mode 100644
index 000000000000..d616d08e3287
--- /dev/null
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSOAndOMRatis.java
@@ -0,0 +1,27 @@
+/*
+ * 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.fs.ozone;
+
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestO3FSWithFSOAndOMRatis extends AbstractOzoneFileSystemTestWithFSO {
+ TestO3FSWithFSOAndOMRatis() {
+ super(true);
+ }
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSPaths.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSPaths.java
new file mode 100644
index 000000000000..5fffd9df7f46
--- /dev/null
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSPaths.java
@@ -0,0 +1,28 @@
+/*
+ * 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.fs.ozone;
+
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestO3FSWithFSPaths extends AbstractOzoneFileSystemTest {
+ TestO3FSWithFSPaths() {
+ super(true, false, BucketLayout.LEGACY);
+ }
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSPathsAndOMRatis.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSPathsAndOMRatis.java
new file mode 100644
index 000000000000..461961c3e73b
--- /dev/null
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithFSPathsAndOMRatis.java
@@ -0,0 +1,28 @@
+/*
+ * 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.fs.ozone;
+
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestO3FSWithFSPathsAndOMRatis extends AbstractOzoneFileSystemTest {
+ TestO3FSWithFSPathsAndOMRatis() {
+ super(true, true, BucketLayout.LEGACY);
+ }
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithOMRatis.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithOMRatis.java
new file mode 100644
index 000000000000..a02f3812e04d
--- /dev/null
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestO3FSWithOMRatis.java
@@ -0,0 +1,28 @@
+/*
+ * 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.fs.ozone;
+
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestO3FSWithOMRatis extends AbstractOzoneFileSystemTest {
+ TestO3FSWithOMRatis() {
+ super(false, true, BucketLayout.LEGACY);
+ }
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileInterfaces.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileInterfaces.java
deleted file mode 100644
index c735e312aac9..000000000000
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileInterfaces.java
+++ /dev/null
@@ -1,647 +0,0 @@
-/*
- * 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.fs.ozone;
-
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.UUID;
-
-import org.apache.hadoop.conf.StorageUnit;
-import org.apache.hadoop.fs.BlockLocation;
-import org.apache.hadoop.fs.FSDataInputStream;
-import org.apache.hadoop.fs.FSDataOutputStream;
-import org.apache.hadoop.fs.FileStatus;
-import org.apache.hadoop.fs.FileSystem;
-import org.apache.hadoop.fs.GlobalStorageStatistics;
-import org.apache.hadoop.fs.LocatedFileStatus;
-import org.apache.hadoop.fs.Path;
-import org.apache.hadoop.fs.StorageStatistics;
-import org.apache.hadoop.fs.permission.FsPermission;
-import org.apache.hadoop.hdds.conf.OzoneConfiguration;
-import org.apache.hadoop.ozone.MiniOzoneCluster;
-import org.apache.hadoop.ozone.OzoneConfigKeys;
-import org.apache.hadoop.ozone.OzoneConsts;
-import org.apache.hadoop.ozone.TestDataUtil;
-import org.apache.hadoop.ozone.client.BucketArgs;
-import org.apache.hadoop.ozone.client.ObjectStore;
-import org.apache.hadoop.ozone.client.OzoneClient;
-import org.apache.hadoop.ozone.client.OzoneVolume;
-import org.apache.hadoop.ozone.om.OMConfigKeys;
-import org.apache.hadoop.ozone.om.OMMetadataManager;
-import org.apache.hadoop.ozone.om.OMMetrics;
-import org.apache.hadoop.ozone.om.helpers.BucketLayout;
-import org.apache.hadoop.ozone.om.helpers.OmKeyArgs;
-import org.apache.hadoop.ozone.om.helpers.OzoneFileStatus;
-import org.apache.hadoop.security.UserGroupInformation;
-import org.apache.hadoop.util.Time;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-import org.apache.hadoop.hdds.utils.IOUtils;
-import org.apache.commons.lang3.RandomStringUtils;
-
-import static org.apache.hadoop.fs.CommonConfigurationKeysPublic.FS_DEFAULT_NAME_KEY;
-import static org.apache.hadoop.fs.ozone.Constants.OZONE_DEFAULT_USER;
-
-import org.junit.After;
-import org.junit.AfterClass;
-
-import static org.apache.hadoop.ozone.om.helpers.BucketLayout.FILE_SYSTEM_OPTIMIZED;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeFalse;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestRule;
-import org.junit.rules.Timeout;
-import org.apache.ozone.test.JUnit5AwareTimeout;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-/**
- * Test OzoneFileSystem Interfaces.
- *
- * This test will test the various interfaces i.e.
- * create, read, write, getFileStatus
- */
-@RunWith(Parameterized.class)
-public class TestOzoneFileInterfaces {
-
- /**
- * Set a timeout for each test.
- */
- @Rule
- public TestRule timeout = new JUnit5AwareTimeout(Timeout.seconds(300));
-
- private String rootPath;
-
- /**
- * Parameter class to set absolute url/defaultFS handling.
- *
- * Hadoop file systems could be used in multiple ways: Using the defaultfs
- * and file path without the schema, or use absolute url-s even with
- * different defaultFS. This parameter matrix would test both the use cases.
- */
- @Parameters
- public static Collection data() {
- return Arrays.asList(new Object[][] {{false, true, true},
- {true, false, false}});
- }
-
- private static boolean setDefaultFs;
-
- private static boolean useAbsolutePath;
-
- private static MiniOzoneCluster cluster = null;
-
- private FileSystem fs;
-
- private OzoneFileSystem o3fs;
-
- private String volumeName;
-
- private String bucketName;
-
- private OzoneFSStorageStatistics statistics;
-
- private OMMetrics omMetrics;
-
- private static boolean enableFileSystemPaths;
-
- @SuppressWarnings("checkstyle:VisibilityModifier")
- protected boolean enableFileSystemPathsInstance;
-
- public TestOzoneFileInterfaces(boolean setDefaultFs,
- boolean useAbsolutePath, boolean enabledFileSystemPaths)
- throws Exception {
- enableFileSystemPathsInstance = enabledFileSystemPaths;
- if (this.setDefaultFs != setDefaultFs
- || this.useAbsolutePath != useAbsolutePath
- || this.enableFileSystemPaths != enabledFileSystemPaths) {
- setParameters(setDefaultFs, useAbsolutePath, enabledFileSystemPaths);
- teardown();
- init();
- }
- GlobalStorageStatistics.INSTANCE.reset();
- }
-
- private static void setParameters(boolean defaultFs,
- boolean absolutePath,
- boolean fileSystemPaths) {
- setDefaultFs = defaultFs;
- useAbsolutePath = absolutePath;
- enableFileSystemPaths = fileSystemPaths;
- }
-
- private static void setCluster(MiniOzoneCluster newCluster) {
- cluster = newCluster;
- }
-
- public void init() throws Exception {
- OzoneConfiguration conf = getOzoneConfiguration();
- conf.set(OMConfigKeys.OZONE_DEFAULT_BUCKET_LAYOUT,
- BucketLayout.LEGACY.name());
- MiniOzoneCluster newCluster = MiniOzoneCluster.newBuilder(conf)
- .setNumDatanodes(3)
- .build();
- newCluster.waitForClusterToBeReady();
- setCluster(newCluster);
- }
-
- @Before
- public void setupTest() throws Exception {
- volumeName = RandomStringUtils.randomAlphabetic(10).toLowerCase();
- bucketName = RandomStringUtils.randomAlphabetic(10).toLowerCase();
-
- OzoneConfiguration conf = cluster.getConf();
-
- // create a volume and a bucket to be used by OzoneFileSystem
- try (OzoneClient client = cluster.newClient()) {
- TestDataUtil.createVolumeAndBucket(client, volumeName, bucketName,
- getBucketLayout());
- }
-
- rootPath = String
- .format("%s://%s.%s/", OzoneConsts.OZONE_URI_SCHEME, bucketName,
- volumeName);
- if (setDefaultFs) {
- // Set the fs.defaultFS and start the filesystem
- conf.set(FS_DEFAULT_NAME_KEY, rootPath);
- fs = FileSystem.get(conf);
- } else {
- fs = FileSystem.get(new URI(rootPath + "/test.txt"), conf);
- }
- o3fs = (OzoneFileSystem) fs;
- statistics = (OzoneFSStorageStatistics) o3fs.getOzoneFSOpsCountStatistics();
- omMetrics = cluster.getOzoneManager().getMetrics();
- }
-
- protected OzoneConfiguration getOzoneConfiguration() {
- OzoneConfiguration conf = new OzoneConfiguration();
- conf.setBoolean(OMConfigKeys.OZONE_OM_ENABLE_FILESYSTEM_PATHS,
- enableFileSystemPaths);
- return conf;
- }
-
- @After
- public void closeFs() throws IOException {
- IOUtils.closeQuietly(fs);
- }
-
- @AfterClass
- public static void teardown() throws IOException {
- if (cluster != null) {
- cluster.shutdown();
- }
- }
-
- @Test
- public void testFileSystemInit() throws IOException {
- assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
-
- if (setDefaultFs) {
- assertTrue(
- "The initialized file system is not OzoneFileSystem but " +
- fs.getClass(),
- fs instanceof OzoneFileSystem);
- assertEquals(OzoneConsts.OZONE_URI_SCHEME, fs.getUri().getScheme());
- assertEquals(OzoneConsts.OZONE_URI_SCHEME, statistics.getScheme());
- }
- }
-
- @Test
- public void testOzFsReadWrite() throws IOException {
- assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
-
- long currentTime = Time.now();
- int stringLen = 20;
- OMMetadataManager metadataManager = cluster.getOzoneManager()
- .getMetadataManager();
- String lev1dir = "l1dir";
- Path lev1path = createPath("/" + lev1dir);
- String lev1key = metadataManager.getOzoneDirKey(volumeName, bucketName,
- o3fs.pathToKey(lev1path));
- String lev2dir = "l2dir";
- Path lev2path = createPath("/" + lev1dir + "/" + lev2dir);
- String lev2key = metadataManager.getOzoneDirKey(volumeName, bucketName,
- o3fs.pathToKey(lev2path));
-
- String data = RandomStringUtils.randomAlphanumeric(stringLen);
- String filePath = RandomStringUtils.randomAlphanumeric(5);
-
- Path path = createPath("/" + lev1dir + "/" + lev2dir + "/" + filePath);
- String fileKey = metadataManager.getOzoneDirKey(volumeName, bucketName,
- o3fs.pathToKey(path));
-
- // verify prefix directories and the file, do not already exist
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(lev1key) == null);
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(lev2key) == null);
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(fileKey) == null);
-
- try (FSDataOutputStream stream = fs.create(path)) {
- stream.writeBytes(data);
- }
-
- assertEquals(statistics.getLong(
- StorageStatistics.CommonStatisticNames.OP_CREATE).longValue(), 1);
- assertEquals(statistics.getLong("objects_created").longValue(), 1);
-
- FileStatus status = fs.getFileStatus(path);
- assertEquals(statistics.getLong(
- StorageStatistics.CommonStatisticNames.OP_GET_FILE_STATUS).longValue(),
- 1);
- assertEquals(statistics.getLong("objects_query").longValue(), 1);
- // The timestamp of the newly created file should always be greater than
- // the time when the test was started
- assertTrue("Modification time has not been recorded: " + status,
- status.getModificationTime() > currentTime);
-
- assertFalse(status.isDirectory());
- assertEquals(FsPermission.getFileDefault(), status.getPermission());
- verifyOwnerGroup(status);
-
- FileStatus lev1status;
- FileStatus lev2status;
-
- // verify prefix directories got created when creating the file.
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(lev1key).getKeyName()
- .equals("l1dir/"));
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(lev2key).getKeyName()
- .equals("l1dir/l2dir/"));
- lev1status = getDirectoryStat(lev1path);
- lev2status = getDirectoryStat(lev2path);
- assertTrue((lev1status != null) && (lev2status != null));
-
- try (FSDataInputStream inputStream = fs.open(path)) {
- byte[] buffer = new byte[stringLen];
- // This read will not change the offset inside the file
- int readBytes = inputStream.read(0, buffer, 0, buffer.length);
- String out = new String(buffer, 0, buffer.length, UTF_8);
- assertEquals(data, out);
- assertEquals(readBytes, buffer.length);
- assertEquals(0, inputStream.getPos());
-
- // The following read will change the internal offset
- readBytes = inputStream.read(buffer, 0, buffer.length);
- assertEquals(data, out);
- assertEquals(readBytes, buffer.length);
- assertEquals(buffer.length, inputStream.getPos());
- }
- assertEquals(statistics.getLong(
- StorageStatistics.CommonStatisticNames.OP_OPEN).longValue(), 1);
- assertEquals(statistics.getLong("objects_read").longValue(), 1);
- }
-
- @Test
- public void testReplication() throws IOException {
- assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
-
- int stringLen = 20;
- String data = RandomStringUtils.randomAlphanumeric(stringLen);
- String filePath = RandomStringUtils.randomAlphanumeric(5);
-
- Path pathIllegal = createPath("/" + filePath + "illegal");
- try (FSDataOutputStream streamIllegal = fs.create(pathIllegal, (short)2)) {
- streamIllegal.writeBytes(data);
- }
- assertEquals(3, fs.getFileStatus(pathIllegal).getReplication());
-
- Path pathLegal = createPath("/" + filePath + "legal");
- try (FSDataOutputStream streamLegal = fs.create(pathLegal, (short)1)) {
- streamLegal.writeBytes(data);
- }
- assertEquals(1, fs.getFileStatus(pathLegal).getReplication());
- }
-
- private void verifyOwnerGroup(FileStatus fileStatus) {
- String owner = getCurrentUser();
- assertEquals(owner, fileStatus.getOwner());
- assertEquals(owner, fileStatus.getGroup());
- }
-
-
- @Test
- public void testDirectory() throws IOException {
- assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
-
- String leafName = RandomStringUtils.randomAlphanumeric(5);
- OMMetadataManager metadataManager = cluster.getOzoneManager()
- .getMetadataManager();
-
- String lev1dir = "abc";
- Path lev1path = createPath("/" + lev1dir);
- String lev1key = metadataManager.getOzoneDirKey(volumeName, bucketName,
- o3fs.pathToKey(lev1path));
- String lev2dir = "def";
- Path lev2path = createPath("/" + lev1dir + "/" + lev2dir);
- String lev2key = metadataManager.getOzoneDirKey(volumeName, bucketName,
- o3fs.pathToKey(lev2path));
-
- FileStatus rootChild;
- FileStatus rootstatus;
- FileStatus leafstatus;
-
- Path leaf = createPath("/" + lev1dir + "/" + lev2dir + "/" + leafName);
- String leafKey = metadataManager.getOzoneDirKey(volumeName, bucketName,
- o3fs.pathToKey(leaf));
-
- // verify prefix directories and the leaf, do not already exist
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(lev1key) == null);
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(lev2key) == null);
- assertTrue(
- metadataManager.getKeyTable(getBucketLayout()).get(leafKey) == null);
-
- assertTrue("Makedirs returned with false for the path " + leaf,
- fs.mkdirs(leaf));
-
- // verify the leaf directory got created.
- leafstatus = getDirectoryStat(leaf);
- assertTrue(leafstatus != null);
-
- FileStatus lev1status;
- FileStatus lev2status;
-
- // verify prefix directories got created when creating the leaf directory.
- assertTrue(metadataManager
- .getKeyTable(getBucketLayout())
- .get(lev1key)
- .getKeyName().equals("abc/"));
- assertTrue(metadataManager
- .getKeyTable(getBucketLayout())
- .get(lev2key)
- .getKeyName().equals("abc/def/"));
- lev1status = getDirectoryStat(lev1path);
- lev2status = getDirectoryStat(lev2path);
- assertTrue((lev1status != null) && (lev2status != null));
- rootChild = lev1status;
-
- // check the root directory
- rootstatus = getDirectoryStat(createPath("/"));
- assertTrue(rootstatus != null);
-
- // root directory listing should contain the lev1 prefix directory
- FileStatus[] statusList = fs.listStatus(createPath("/"));
- assertEquals(1, statusList.length);
- assertEquals(rootChild, statusList[0]);
- }
-
- @Test
- public void testListStatus() throws IOException {
- List paths = new ArrayList<>();
- String dirPath = RandomStringUtils.randomAlphanumeric(5);
- Path path = createPath("/" + dirPath);
- paths.add(path);
-
- long mkdirs = statistics.getLong(
- StorageStatistics.CommonStatisticNames.OP_MKDIRS);
- assertTrue("Makedirs returned with false for the path " + path,
- fs.mkdirs(path));
- assertCounter(++mkdirs, StorageStatistics.CommonStatisticNames.OP_MKDIRS);
-
- long listObjects = statistics.getLong(Statistic.OBJECTS_LIST.getSymbol());
- long omListStatus = omMetrics.getNumListStatus();
- FileStatus[] statusList = fs.listStatus(createPath("/"));
- assertEquals(1, statusList.length);
- assertCounter(++listObjects, Statistic.OBJECTS_LIST.getSymbol());
- assertEquals(++omListStatus, omMetrics.getNumListStatus());
- assertEquals(fs.getFileStatus(path), statusList[0]);
-
- dirPath = RandomStringUtils.randomAlphanumeric(5);
- path = createPath("/" + dirPath);
- paths.add(path);
- assertTrue("Makedirs returned with false for the path " + path,
- fs.mkdirs(path));
- assertCounter(++mkdirs, StorageStatistics.CommonStatisticNames.OP_MKDIRS);
-
- statusList = fs.listStatus(createPath("/"));
- assertEquals(2, statusList.length);
- assertCounter(++listObjects, Statistic.OBJECTS_LIST.getSymbol());
- assertEquals(++omListStatus, omMetrics.getNumListStatus());
- for (Path p : paths) {
- assertTrue(Arrays.asList(statusList).contains(fs.getFileStatus(p)));
- }
- }
-
- @Test
- public void testOzoneManagerFileSystemInterface() throws IOException {
- String dirPath = RandomStringUtils.randomAlphanumeric(5);
-
- Path path = createPath("/" + dirPath);
- assertTrue("Makedirs returned with false for the path " + path,
- fs.mkdirs(path));
-
- long numFileStatus =
- cluster.getOzoneManager().getMetrics().getNumGetFileStatus();
- FileStatus status = fs.getFileStatus(path);
-
- assertEquals(numFileStatus + 1,
- cluster.getOzoneManager().getMetrics().getNumGetFileStatus());
- assertTrue(status.isDirectory());
- assertEquals(FsPermission.getDirDefault(), status.getPermission());
- verifyOwnerGroup(status);
-
- long currentTime = System.currentTimeMillis();
- OmKeyArgs keyArgs = new OmKeyArgs.Builder()
- .setVolumeName(volumeName)
- .setBucketName(bucketName)
- .setKeyName(o3fs.pathToKey(path))
- .build();
- OzoneFileStatus omStatus =
- cluster.getOzoneManager().getFileStatus(keyArgs);
- //Another get file status here, incremented the counter.
- assertEquals(numFileStatus + 2,
- cluster.getOzoneManager().getMetrics().getNumGetFileStatus());
-
- assertTrue("The created path is not directory.", omStatus.isDirectory());
-
- // For directories, the time returned is the current time when the dir key
- // doesn't actually exist on server; if it exists, it will be a fixed value.
- // In this case, the dir key exists.
- assertEquals(0, omStatus.getKeyInfo().getDataSize());
- assertTrue(omStatus.getKeyInfo().getModificationTime() <= currentTime);
- assertEquals(new Path(omStatus.getPath()).getName(),
- o3fs.pathToKey(path));
- }
-
- @Test
- public void testOzoneManagerLocatedFileStatus() throws IOException {
- String data = RandomStringUtils.randomAlphanumeric(20);
- String filePath = RandomStringUtils.randomAlphanumeric(5);
- Path path = createPath("/" + filePath);
- try (FSDataOutputStream stream = fs.create(path)) {
- stream.writeBytes(data);
- }
- FileStatus status = fs.getFileStatus(path);
- assertTrue(status instanceof LocatedFileStatus);
- LocatedFileStatus locatedFileStatus = (LocatedFileStatus) status;
- assertTrue(locatedFileStatus.getBlockLocations().length >= 1);
-
- for (BlockLocation blockLocation : locatedFileStatus.getBlockLocations()) {
- assertTrue(blockLocation.getNames().length >= 1);
- assertTrue(blockLocation.getHosts().length >= 1);
- }
- }
-
- @Test
- public void testOzoneManagerLocatedFileStatusBlockOffsetsWithMultiBlockFile()
- throws Exception {
- // naive assumption: MiniOzoneCluster will not have larger than ~1GB
- // block size when running this test.
- int blockSize = (int) fs.getConf().getStorageSize(
- OzoneConfigKeys.OZONE_SCM_BLOCK_SIZE,
- OzoneConfigKeys.OZONE_SCM_BLOCK_SIZE_DEFAULT,
- StorageUnit.BYTES
- );
- String data = RandomStringUtils.randomAlphanumeric(2 * blockSize + 837);
- String filePath = RandomStringUtils.randomAlphanumeric(5);
- Path path = createPath("/" + filePath);
- try (FSDataOutputStream stream = fs.create(path)) {
- stream.writeBytes(data);
- }
- FileStatus status = fs.getFileStatus(path);
- assertTrue(status instanceof LocatedFileStatus);
- LocatedFileStatus locatedFileStatus = (LocatedFileStatus) status;
- BlockLocation[] blockLocations = locatedFileStatus.getBlockLocations();
-
- assertEquals(0, blockLocations[0].getOffset());
- assertEquals(blockSize, blockLocations[1].getOffset());
- assertEquals(2 * blockSize, blockLocations[2].getOffset());
- assertEquals(blockSize, blockLocations[0].getLength());
- assertEquals(blockSize, blockLocations[1].getLength());
- assertEquals(837, blockLocations[2].getLength());
- }
-
- @Test
- public void testPathToKey() throws Exception {
- assumeFalse(FILE_SYSTEM_OPTIMIZED.equals(getBucketLayout()));
-
- assertEquals("a/b/1", o3fs.pathToKey(new Path("/a/b/1")));
-
- assertEquals("user/" + getCurrentUser() + "/key1/key2",
- o3fs.pathToKey(new Path("key1/key2")));
-
- assertEquals("key1/key2",
- o3fs.pathToKey(new Path("o3fs://test1/key1/key2")));
- }
-
-
- /**
- * Verify that FS throws exception when trying to access bucket with
- * incompatible layout.
- * @throws IOException
- */
- @Test
- public void testFileSystemWithObjectStoreLayout() throws IOException {
- String obsVolume = UUID.randomUUID().toString();
-
- try (OzoneClient client = cluster.newClient()) {
- ObjectStore store = client.getObjectStore();
-
- // Create volume and bucket
- store.createVolume(obsVolume);
- OzoneVolume volume = store.getVolume(obsVolume);
- String obsBucket = UUID.randomUUID().toString();
- // create bucket with OBJECT_STORE bucket layout (incompatible with fs)
- volume.createBucket(obsBucket,
- BucketArgs.newBuilder().setBucketLayout(BucketLayout.OBJECT_STORE)
- .build());
-
- String obsRootPath = String.format("%s://%s.%s/",
- OzoneConsts.OZONE_URI_SCHEME, obsBucket, obsVolume);
-
- OzoneConfiguration config = (OzoneConfiguration) fs.getConf();
- config.set(FS_DEFAULT_NAME_KEY, obsRootPath);
-
- try {
- fs = FileSystem.get(fs.getConf());
- fail("Should throw Exception due incompatible bucket layout");
- } catch (IllegalArgumentException iae) {
- // Expected exception
- assertTrue(iae.getMessage().contains(
- "OBJECT_STORE, which does not support file system semantics"));
- }
- }
- }
-
- private String getCurrentUser() {
- try {
- return UserGroupInformation.getCurrentUser().getShortUserName();
- } catch (IOException e) {
- return OZONE_DEFAULT_USER;
- }
- }
-
- private Path createPath(String relativePath) {
- if (useAbsolutePath) {
- return new Path(
- rootPath + (relativePath.startsWith("/") ? "" : "/") + relativePath);
- } else {
- return new Path(relativePath);
- }
- }
-
- /**
- * verify that a directory exists and is initialized correctly.
- * @param path of the directory
- * @return null indicates FILE_NOT_FOUND, else the FileStatus
- * @throws IOException
- */
- private FileStatus getDirectoryStat(Path path) throws IOException {
-
- FileStatus status = null;
-
- try {
- status = fs.getFileStatus(path);
- } catch (FileNotFoundException e) {
- return null;
- }
- assertTrue("The created path is not directory.", status.isDirectory());
-
- assertEquals(FsPermission.getDirDefault(), status.getPermission());
- verifyOwnerGroup(status);
-
- assertEquals(0, status.getLen());
-
- return status;
- }
-
- private void assertCounter(long value, String key) {
- assertEquals(value, statistics.getLong(key).longValue());
- }
-
- public BucketLayout getBucketLayout() {
- return BucketLayout.DEFAULT;
- }
-}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSafeMode.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSafeMode.java
index d97bc5b33754..f285abfaf75b 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSafeMode.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestSafeMode.java
@@ -20,7 +20,9 @@
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.SafeMode;
import org.apache.hadoop.fs.SafeModeAction;
+import org.apache.hadoop.hdds.client.RatisReplicationConfig;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.scm.container.common.helpers.ExcludeList;
import org.apache.hadoop.hdds.utils.IOUtils;
import org.apache.hadoop.ozone.MiniOzoneCluster;
import org.apache.hadoop.ozone.MiniOzoneClusterProvider;
@@ -30,18 +32,24 @@
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
import java.io.IOException;
import java.net.URI;
import java.util.function.Function;
+import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.THREE;
+import static org.apache.hadoop.ozone.OzoneConsts.MB;
+import static org.apache.hadoop.ozone.OzoneConsts.OZONE;
import static org.apache.hadoop.ozone.OzoneConsts.OZONE_OFS_URI_SCHEME;
import static org.apache.hadoop.ozone.OzoneConsts.OZONE_URI_SCHEME;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_ADDRESS_KEY;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
+@Timeout(60)
class TestSafeMode {
private static final String VOLUME = "vol";
@@ -106,6 +114,13 @@ private void testSafeMode(Function fsRoot)
// force exit safe mode and verify that it's out of safe mode.
subject.setSafeMode(SafeModeAction.FORCE_EXIT);
assertFalse(subject.setSafeMode(SafeModeAction.GET));
+
+ // datanodes are still stopped
+ RatisReplicationConfig replication =
+ RatisReplicationConfig.getInstance(THREE);
+ assertThrows(IOException.class, () -> cluster.getStorageContainerManager()
+ .getWritableContainerFactory()
+ .getContainer(MB, replication, OZONE, new ExcludeList()));
} finally {
IOUtils.closeQuietly(fs);
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/storage/TestContainerCommandsEC.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/storage/TestContainerCommandsEC.java
index c5f123935383..a35e2198c110 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/storage/TestContainerCommandsEC.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/storage/TestContainerCommandsEC.java
@@ -452,10 +452,10 @@ public void testCreateRecoveryContainer() throws Exception {
.generateToken(ANY_USER, container.containerID());
scm.getContainerManager().getContainerStateManager()
.addContainer(container.getProtobuf());
-
+ int replicaIndex = 4;
XceiverClientSpi dnClient = xceiverClientManager.acquireClient(
createSingleNodePipeline(newPipeline, newPipeline.getNodes().get(0),
- 2));
+ replicaIndex));
try {
// To create the actual situation, container would have been in closed
// state at SCM.
@@ -470,7 +470,7 @@ public void testCreateRecoveryContainer() throws Exception {
String encodedToken = cToken.encodeToUrlString();
ContainerProtocolCalls.createRecoveringContainer(dnClient,
container.containerID().getProtobuf().getId(),
- encodedToken, 4);
+ encodedToken, replicaIndex);
BlockID blockID = ContainerTestHelper
.getTestBlockID(container.containerID().getProtobuf().getId());
@@ -511,7 +511,8 @@ public void testCreateRecoveryContainer() throws Exception {
readContainerResponseProto.getContainerData().getState());
ContainerProtos.ReadChunkResponseProto readChunkResponseProto =
ContainerProtocolCalls.readChunk(dnClient,
- writeChunkRequest.getWriteChunk().getChunkData(), blockID, null,
+ writeChunkRequest.getWriteChunk().getChunkData(),
+ blockID.getDatanodeBlockIDProtobufBuilder().setReplicaIndex(replicaIndex).build(), null,
blockToken);
ByteBuffer[] readOnlyByteBuffersArray = BufferUtils
.getReadOnlyByteBuffersArray(
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestBlockTokens.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestBlockTokens.java
index f410c50c4662..752c011f4688 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestBlockTokens.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestBlockTokens.java
@@ -22,6 +22,7 @@
import org.apache.hadoop.hdds.annotation.InterfaceAudience;
import org.apache.hadoop.hdds.conf.DefaultConfigManager;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.scm.OzoneClientConfig;
import org.apache.hadoop.hdds.scm.ScmConfig;
import org.apache.hadoop.hdds.scm.XceiverClientFactory;
import org.apache.hadoop.hdds.scm.container.common.helpers.StorageContainerException;
@@ -305,9 +306,11 @@ private void readData(OmKeyInfo keyInfo,
Function retryFunc) throws IOException {
XceiverClientFactory xceiverClientManager =
((RpcClient) client.getProxy()).getXceiverClientManager();
+ OzoneClientConfig clientConfig = conf.getObject(OzoneClientConfig.class);
+ clientConfig.setChecksumVerify(false);
try (InputStream is = KeyInputStream.getFromOmKeyInfo(keyInfo,
- xceiverClientManager,
- false, retryFunc, blockInputStreamFactory)) {
+ xceiverClientManager, retryFunc, blockInputStreamFactory,
+ clientConfig)) {
byte[] buf = new byte[100];
int readBytes = is.read(buf, 0, 100);
assertEquals(100, readBytes);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOzoneConfigurationFields.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOzoneConfigurationFields.java
index cb29d61e1a4c..1a437be8131b 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOzoneConfigurationFields.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOzoneConfigurationFields.java
@@ -141,7 +141,10 @@ private void addPropertiesNotInXml() {
ScmConfigKeys.OZONE_SCM_PIPELINE_PLACEMENT_IMPL_KEY,
ScmConfigKeys.OZONE_SCM_HA_PREFIX,
S3GatewayConfigKeys.OZONE_S3G_FSO_DIRECTORY_CREATION_ENABLED,
- HddsConfigKeys.HDDS_DATANODE_VOLUME_MIN_FREE_SPACE_PERCENT
+ HddsConfigKeys.HDDS_DATANODE_VOLUME_MIN_FREE_SPACE_PERCENT,
+ OzoneConfigKeys.HDDS_SCM_CLIENT_RPC_TIME_OUT,
+ OzoneConfigKeys.HDDS_SCM_CLIENT_MAX_RETRY_TIMEOUT,
+ OzoneConfigKeys.HDDS_SCM_CLIENT_FAILOVER_MAX_RETRY
));
}
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientWithRatis.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientWithRatis.java
index c3bbd793dc1c..3a8d117bc6d5 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientWithRatis.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientWithRatis.java
@@ -28,6 +28,7 @@
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.HashMap;
+import java.util.Locale;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;
@@ -65,6 +66,8 @@
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.hadoop.hdds.client.ReplicationFactor.ONE;
@@ -183,12 +186,13 @@ public void testGetKeyAndFileWithNetworkTopology() throws IOException {
}
}
- @Test
- public void testMultiPartUploadWithStream()
+ @ParameterizedTest
+ @MethodSource("replicationConfigs")
+ void testMultiPartUploadWithStream(ReplicationConfig replicationConfig)
throws IOException, NoSuchAlgorithmException {
String volumeName = UUID.randomUUID().toString();
- String bucketName = UUID.randomUUID().toString();
- String keyName = UUID.randomUUID().toString();
+ String bucketName = replicationConfig.getReplicationType().name().toLowerCase(Locale.ROOT) + "-bucket";
+ String keyName = replicationConfig.getReplication();
byte[] sampleData = new byte[1024 * 8];
@@ -199,11 +203,6 @@ public void testMultiPartUploadWithStream()
volume.createBucket(bucketName);
OzoneBucket bucket = volume.getBucket(bucketName);
- ReplicationConfig replicationConfig =
- ReplicationConfig.fromTypeAndFactor(
- ReplicationType.RATIS,
- THREE);
-
OmMultipartInfo multipartInfo = bucket.initiateMultipartUpload(keyName,
replicationConfig);
@@ -226,7 +225,7 @@ public void testMultiPartUploadWithStream()
OzoneMultipartUploadPartListParts parts =
bucket.listParts(keyName, uploadID, 0, 1);
- Assert.assertEquals(parts.getPartInfoList().size(), 1);
+ Assert.assertEquals(1, parts.getPartInfoList().size());
OzoneMultipartUploadPartListParts.PartInfo partInfo =
parts.getPartInfoList().get(0);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/TestContainerReplication.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/TestContainerReplication.java
index 28d19d0be87b..0a6da3d49ec5 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/TestContainerReplication.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/TestContainerReplication.java
@@ -21,7 +21,9 @@
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyMap;
+import static org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos.ContainerType.KeyValueContainer;
import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.THREE;
+import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_CONTAINER_PLACEMENT_EC_IMPL_KEY;
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_CONTAINER_PLACEMENT_IMPL_KEY;
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_DEADNODE_INTERVAL;
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
@@ -30,36 +32,62 @@
import static org.apache.ozone.test.GenericTestUtils.setLogLevel;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.any;
import java.io.IOException;
import java.io.OutputStream;
import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import com.google.common.base.Functions;
+import com.google.common.collect.ImmutableMap;
+import org.apache.hadoop.hdds.client.ECReplicationConfig;
import org.apache.hadoop.hdds.client.RatisReplicationConfig;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.protocol.DatanodeDetails;
+import org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos;
import org.apache.hadoop.hdds.scm.PlacementPolicy;
+import org.apache.hadoop.hdds.scm.container.placement.algorithms.SCMContainerPlacementRackScatter;
import org.apache.hadoop.hdds.scm.container.replication.ReplicationManager.ReplicationManagerConfiguration;
import org.apache.hadoop.hdds.scm.container.placement.algorithms.SCMContainerPlacementCapacity;
import org.apache.hadoop.hdds.scm.container.placement.algorithms.SCMContainerPlacementRackAware;
import org.apache.hadoop.hdds.scm.container.placement.algorithms.SCMContainerPlacementRandom;
+import org.apache.hadoop.hdds.scm.storage.ContainerProtocolCalls;
+import org.apache.hadoop.ozone.HddsDatanodeService;
import org.apache.hadoop.ozone.MiniOzoneCluster;
import org.apache.hadoop.ozone.client.ObjectStore;
import org.apache.hadoop.ozone.client.OzoneBucket;
import org.apache.hadoop.ozone.client.OzoneClient;
+import org.apache.hadoop.ozone.client.OzoneClientFactory;
import org.apache.hadoop.ozone.client.OzoneVolume;
+import org.apache.hadoop.ozone.client.io.OzoneInputStream;
+import org.apache.hadoop.ozone.container.common.interfaces.Container;
+import org.apache.hadoop.ozone.container.ozoneimpl.OzoneContainer;
import org.apache.hadoop.ozone.om.helpers.OmKeyArgs;
import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfo;
import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfoGroup;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
import org.slf4j.event.Level;
/**
@@ -159,6 +187,22 @@ private void createTestData(OzoneClient client) throws IOException {
}
}
+ private byte[] createTestData(OzoneClient client, int size) throws IOException {
+ ObjectStore objectStore = client.getObjectStore();
+ objectStore.createVolume(VOLUME);
+ OzoneVolume volume = objectStore.getVolume(VOLUME);
+ volume.createBucket(BUCKET);
+ OzoneBucket bucket = volume.getBucket(BUCKET);
+ try (OutputStream out = bucket.createKey(KEY, 0, new ECReplicationConfig("RS-3-2-1k"),
+ new HashMap<>())) {
+ byte[] b = new byte[size];
+ Random random = new Random();
+ random.nextBytes(b);
+ out.write(b);
+ return b;
+ }
+ }
+
private static List lookupKey(MiniOzoneCluster cluster)
throws IOException {
OmKeyArgs keyArgs = new OmKeyArgs.Builder()
@@ -172,4 +216,155 @@ private static List lookupKey(MiniOzoneCluster cluster)
return locations.getLocationList();
}
+ private static OmKeyLocationInfo lookupKeyFirstLocation(MiniOzoneCluster cluster)
+ throws IOException {
+ OmKeyArgs keyArgs = new OmKeyArgs.Builder()
+ .setVolumeName(VOLUME)
+ .setBucketName(BUCKET)
+ .setKeyName(KEY)
+ .build();
+ OmKeyInfo keyInfo = cluster.getOzoneManager().lookupKey(keyArgs);
+ OmKeyLocationInfoGroup locations = keyInfo.getLatestVersionLocations();
+ Assertions.assertNotNull(locations);
+ return locations.getLocationList().get(0);
+ }
+
+
+ public void assertState(MiniOzoneCluster cluster, Map expectedReplicaMap)
+ throws IOException {
+ OmKeyLocationInfo keyLocation = lookupKeyFirstLocation(cluster);
+ Map replicaMap =
+ keyLocation.getPipeline().getNodes().stream().collect(Collectors.toMap(
+ dn -> keyLocation.getPipeline().getReplicaIndex(dn), Functions.identity()));
+ Assertions.assertEquals(expectedReplicaMap, replicaMap);
+ }
+
+ private OzoneInputStream createInputStream(OzoneClient client) throws IOException {
+ ObjectStore objectStore = client.getObjectStore();
+ OzoneVolume volume = objectStore.getVolume(VOLUME);
+ OzoneBucket bucket = volume.getBucket(BUCKET);
+ return bucket.readKey(KEY);
+ }
+
+ private void mockContainerProtocolCalls(final MockedStatic mockedContainerProtocolCalls,
+ final Map failedReadChunkCountMap) {
+ mockedContainerProtocolCalls.when(() -> ContainerProtocolCalls.readChunk(any(), any(), any(), anyList(), any()))
+ .thenAnswer(invocation -> {
+ int replicaIndex = ((ContainerProtos.DatanodeBlockID) invocation.getArgument(2)).getReplicaIndex();
+ try {
+ return invocation.callRealMethod();
+ } catch (Throwable e) {
+ failedReadChunkCountMap.compute(replicaIndex,
+ (replicaIdx, totalCount) -> totalCount == null ? 1 : (totalCount + 1));
+ throw e;
+ }
+ });
+ }
+
+
+ private static void deleteContainer(MiniOzoneCluster cluster, DatanodeDetails dn, long containerId)
+ throws IOException {
+ OzoneContainer container = cluster.getHddsDatanode(dn).getDatanodeStateMachine().getContainer();
+ Container containerData = container.getContainerSet().getContainer(containerId);
+ if (containerData != null) {
+ container.getDispatcher().getHandler(KeyValueContainer).deleteContainer(containerData, true);
+ }
+ cluster.getHddsDatanode(dn).getDatanodeStateMachine().triggerHeartbeat();
+ }
+
+
+ @Test
+ public void testECContainerReplication() throws Exception {
+ OzoneConfiguration conf = createConfiguration(false);
+ final Map failedReadChunkCountMap = new ConcurrentHashMap<>();
+ // Overiding Config to support 1k Chunk size
+ conf.set("ozone.replication.allowed-configs", "(^((STANDALONE|RATIS)/(ONE|THREE))|(EC/(3-2|6-3|10-4)-" +
+ "(512|1024|2048|4096|1)k)$)");
+ conf.set(OZONE_SCM_CONTAINER_PLACEMENT_EC_IMPL_KEY, SCMContainerPlacementRackScatter.class.getCanonicalName());
+ try (MockedStatic mockedContainerProtocolCalls =
+ Mockito.mockStatic(ContainerProtocolCalls.class, Mockito.CALLS_REAL_METHODS);) {
+ mockContainerProtocolCalls(mockedContainerProtocolCalls, failedReadChunkCountMap);
+ // Creating Cluster with 5 Nodes
+ try (MiniOzoneCluster cluster = MiniOzoneCluster.newBuilder(conf).setNumDatanodes(5).build()) {
+ cluster.waitForClusterToBeReady();
+ try (OzoneClient client = OzoneClientFactory.getRpcClient(conf)) {
+ Set allNodes =
+ cluster.getHddsDatanodes().stream().map(HddsDatanodeService::getDatanodeDetails).collect(
+ Collectors.toSet());
+ List initialNodesWithData = new ArrayList<>();
+ // Keeping 5 DNs and stopping the 6th Node here it is kept in the var extraNodes
+ for (DatanodeDetails dn : allNodes) {
+ if (initialNodesWithData.size() < 5) {
+ initialNodesWithData.add(dn);
+ } else {
+ cluster.shutdownHddsDatanode(dn);
+ }
+ }
+
+ // Creating 2 stripes with Chunk Size 1k
+ int size = 6 * 1024;
+ byte[] originalData = createTestData(client, size);
+
+ // Getting latest location of the key
+ final OmKeyLocationInfo keyLocation = lookupKeyFirstLocation(cluster);
+ long containerID = keyLocation.getContainerID();
+ waitForContainerClose(cluster, containerID);
+
+ // Forming Replica Index Map
+ Map replicaIndexMap =
+ initialNodesWithData.stream().map(dn -> new Object[]{dn, keyLocation.getPipeline().getReplicaIndex(dn)})
+ .collect(
+ Collectors.toMap(x -> (Integer) x[1], x -> (DatanodeDetails) x[0]));
+
+ //Reading through file and comparing with input data.
+ byte[] readData = new byte[size];
+ try (OzoneInputStream inputStream = createInputStream(client)) {
+ inputStream.read(readData);
+ Assertions.assertArrayEquals(readData, originalData);
+ }
+ Assertions.assertEquals(0, failedReadChunkCountMap.size());
+ //Opening a new stream before we make changes to the blocks.
+ try (OzoneInputStream inputStream = createInputStream(client)) {
+ int firstReadLen = 1024 * 3;
+ Arrays.fill(readData, (byte) 0);
+ //Reading first stripe.
+ inputStream.read(readData, 0, firstReadLen);
+ Assertions.assertEquals(0, failedReadChunkCountMap.size());
+ //Checking the initial state as per the latest location.
+ assertState(cluster, ImmutableMap.of(1, replicaIndexMap.get(1), 2, replicaIndexMap.get(2),
+ 3, replicaIndexMap.get(3), 4, replicaIndexMap.get(4), 5, replicaIndexMap.get(5)));
+
+ // Stopping replication manager
+ cluster.getStorageContainerManager().getReplicationManager().stop();
+ // Deleting the container from DN1 & DN3
+ deleteContainer(cluster, replicaIndexMap.get(1), containerID);
+ deleteContainer(cluster, replicaIndexMap.get(3), containerID);
+ // Waiting for replica count of container to come down to 3.
+ waitForReplicaCount(containerID, 3, cluster);
+ // Shutting down DN1
+ cluster.shutdownHddsDatanode(replicaIndexMap.get(1));
+ // Starting replication manager which should process under replication & write replica 1 to DN3.
+ cluster.getStorageContainerManager().getReplicationManager().start();
+ waitForReplicaCount(containerID, 4, cluster);
+ // Asserting Replica 1 has been written to DN3.
+ assertState(cluster, ImmutableMap.of(1, replicaIndexMap.get(3), 2, replicaIndexMap.get(2),
+ 4, replicaIndexMap.get(4), 5, replicaIndexMap.get(5)));
+ // Starting DN1.
+ cluster.restartHddsDatanode(replicaIndexMap.get(1), false);
+ // Waiting for underreplication to get resolved.
+ waitForReplicaCount(containerID, 5, cluster);
+ // Asserting Replica 1 & Replica 3 has been swapped b/w DN1 & DN3.
+ assertState(cluster, ImmutableMap.of(1, replicaIndexMap.get(3), 2, replicaIndexMap.get(2),
+ 3, replicaIndexMap.get(1), 4, replicaIndexMap.get(4), 5, replicaIndexMap.get(5)));
+ // Reading the Stripe 2 from the pre initialized inputStream
+ inputStream.read(readData, firstReadLen, size - firstReadLen);
+ // Asserting there was a failure in the first read chunk.
+ Assertions.assertEquals(ImmutableMap.of(1, 1, 3, 1), failedReadChunkCountMap);
+ Assertions.assertArrayEquals(readData, originalData);
+ }
+ }
+ }
+ }
+ }
+
}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
index 88fb0107969c..114ba1a21bbf 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/freon/TestOMSnapshotDAG.java
@@ -29,7 +29,6 @@
import org.apache.hadoop.ozone.client.OzoneBucket;
import org.apache.hadoop.ozone.client.OzoneClient;
import org.apache.hadoop.ozone.client.OzoneVolume;
-import org.apache.hadoop.ozone.om.IOmMetadataReader;
import org.apache.hadoop.ozone.om.OMConfigKeys;
import org.apache.hadoop.ozone.om.OMMetadataManager;
import org.apache.hadoop.ozone.om.OmSnapshot;
@@ -39,7 +38,6 @@
import org.apache.hadoop.ozone.om.helpers.OmVolumeArgs;
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
import org.apache.hadoop.ozone.om.snapshot.ReferenceCounted;
-import org.apache.hadoop.ozone.om.snapshot.SnapshotCache;
import org.apache.ozone.rocksdiff.DifferSnapshotInfo;
import org.apache.ozone.rocksdiff.RocksDBCheckpointDiffer;
import org.apache.ozone.test.GenericTestUtils;
@@ -213,20 +211,16 @@ public void testDAGReconstruction()
OMMetadataManager omMetadataManager = ozoneManager.getMetadataManager();
RDBStore rdbStore = (RDBStore) omMetadataManager.getStore();
RocksDBCheckpointDiffer differ = rdbStore.getRocksDBCheckpointDiffer();
- ReferenceCounted
- snapDB1 = ozoneManager.getOmSnapshotManager()
- .getSnapshotCache().get(
- SnapshotInfo.getTableKey(volumeName, bucketName, "snap1"));
- ReferenceCounted
- snapDB2 = ozoneManager.getOmSnapshotManager()
- .getSnapshotCache().get(
- SnapshotInfo.getTableKey(volumeName, bucketName, "snap2"));
+ ReferenceCounted snapDB1 = ozoneManager.getOmSnapshotManager()
+ .getActiveSnapshot(volumeName, bucketName, "snap1");
+ ReferenceCounted snapDB2 = ozoneManager.getOmSnapshotManager()
+ .getActiveSnapshot(volumeName, bucketName, "snap2");
DifferSnapshotInfo snap1 = getDifferSnapshotInfo(omMetadataManager,
volumeName, bucketName, "snap1",
- ((RDBStore)((OmSnapshot)snapDB1.get())
+ ((RDBStore) snapDB1.get()
.getMetadataManager().getStore()).getDb().getManagedRocksDb());
DifferSnapshotInfo snap2 = getDifferSnapshotInfo(omMetadataManager,
- volumeName, bucketName, "snap2", ((RDBStore)((OmSnapshot)snapDB2.get())
+ volumeName, bucketName, "snap2", ((RDBStore) snapDB2.get()
.getMetadataManager().getStore()).getDb().getManagedRocksDb());
// RocksDB does checkpointing in a separate thread, wait for it
@@ -245,13 +239,11 @@ public void testDAGReconstruction()
resp = store.createSnapshot(volumeName, bucketName, "snap3");
LOG.debug("Snapshot created: {}", resp);
- ReferenceCounted
- snapDB3 = ozoneManager.getOmSnapshotManager()
- .getSnapshotCache().get(
- SnapshotInfo.getTableKey(volumeName, bucketName, "snap3"));
+ ReferenceCounted snapDB3 = ozoneManager.getOmSnapshotManager()
+ .getActiveSnapshot(volumeName, bucketName, "snap3");
DifferSnapshotInfo snap3 = getDifferSnapshotInfo(omMetadataManager,
volumeName, bucketName, "snap3",
- ((RDBStore)((OmSnapshot)snapDB3.get())
+ ((RDBStore) snapDB3.get()
.getMetadataManager().getStore()).getDb().getManagedRocksDb());
final File checkpointSnap3 = new File(snap3.getDbPath());
GenericTestUtils.waitFor(checkpointSnap3::exists, 2000, 20000);
@@ -272,24 +264,21 @@ public void testDAGReconstruction()
ozoneManager = cluster.getOzoneManager();
omMetadataManager = ozoneManager.getMetadataManager();
snapDB1 = ozoneManager.getOmSnapshotManager()
- .getSnapshotCache().get(
- SnapshotInfo.getTableKey(volumeName, bucketName, "snap1"));
+ .getActiveSnapshot(volumeName, bucketName, "snap1");
snapDB2 = ozoneManager.getOmSnapshotManager()
- .getSnapshotCache().get(
- SnapshotInfo.getTableKey(volumeName, bucketName, "snap2"));
+ .getActiveSnapshot(volumeName, bucketName, "snap2");
snap1 = getDifferSnapshotInfo(omMetadataManager,
volumeName, bucketName, "snap1",
- ((RDBStore)((OmSnapshot)snapDB1.get())
+ ((RDBStore) snapDB1.get()
.getMetadataManager().getStore()).getDb().getManagedRocksDb());
snap2 = getDifferSnapshotInfo(omMetadataManager,
- volumeName, bucketName, "snap2", ((RDBStore)((OmSnapshot)snapDB2.get())
+ volumeName, bucketName, "snap2", ((RDBStore) snapDB2.get()
.getMetadataManager().getStore()).getDb().getManagedRocksDb());
snapDB3 = ozoneManager.getOmSnapshotManager()
- .getSnapshotCache().get(
- SnapshotInfo.getTableKey(volumeName, bucketName, "snap3"));
+ .getActiveSnapshot(volumeName, bucketName, "snap3");
snap3 = getDifferSnapshotInfo(omMetadataManager,
volumeName, bucketName, "snap3",
- ((RDBStore)((OmSnapshot)snapDB3.get())
+ ((RDBStore) snapDB3.get()
.getMetadataManager().getStore()).getDb().getManagedRocksDb());
List sstDiffList21Run2 = differ.getSSTDiffList(snap2, snap1);
Assertions.assertEquals(sstDiffList21, sstDiffList21Run2);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestAddRemoveOzoneManager.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestAddRemoveOzoneManager.java
index f2d6a0d80d2c..67083d63bb2c 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestAddRemoveOzoneManager.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestAddRemoveOzoneManager.java
@@ -46,7 +46,6 @@
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hadoop.util.StringUtils;
import org.apache.ozone.test.GenericTestUtils;
-import org.apache.ozone.test.tag.Flaky;
import org.apache.ratis.grpc.server.GrpcLogAppender;
import org.apache.ratis.server.leader.FollowerInfo;
import org.junit.Assert;
@@ -174,7 +173,6 @@ private List testBootstrapOMs(int numNewOMs) throws Exception {
* OM.
*/
@Test
- @Flaky("HDDS-7880")
public void testBootstrap() throws Exception {
setupCluster(1);
OzoneManager oldOM = cluster.getOzoneManager();
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotBackgroundServices.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotBackgroundServices.java
index 682d02cd2861..8bd78460c1bd 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotBackgroundServices.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotBackgroundServices.java
@@ -41,7 +41,6 @@
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
import org.apache.hadoop.ozone.om.ratis.OzoneManagerRatisServerConfig;
import org.apache.hadoop.ozone.om.snapshot.ReferenceCounted;
-import org.apache.hadoop.ozone.om.snapshot.SnapshotCache;
import org.apache.hadoop.ozone.snapshot.SnapshotDiffReportOzone;
import org.apache.hadoop.ozone.snapshot.SnapshotDiffResponse;
import org.apache.ozone.compaction.log.CompactionLogEntry;
@@ -78,7 +77,6 @@
import static org.apache.hadoop.ozone.OzoneConsts.OM_KEY_PREFIX;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_SNAPSHOT_SST_FILTERING_SERVICE_INTERVAL;
import static org.apache.hadoop.ozone.om.OmSnapshotManager.getSnapshotPath;
-import static org.apache.hadoop.ozone.om.OmSnapshotManager.getSnapshotPrefix;
import static org.apache.hadoop.ozone.om.TestOzoneManagerHAWithStoppedNodes.createKey;
import static org.apache.hadoop.ozone.snapshot.SnapshotDiffResponse.JobStatus.DONE;
@@ -262,12 +260,11 @@ public void testSnapshotAndKeyDeletionBackgroundServices()
// get snapshot c
OmSnapshot snapC;
- try (ReferenceCounted rcC = newLeaderOM
+ try (ReferenceCounted rcC = newLeaderOM
.getOmSnapshotManager()
- .checkForSnapshot(volumeName, bucketName,
- getSnapshotPrefix(snapshotInfoC.getName()), true)) {
+ .getSnapshot(volumeName, bucketName, snapshotInfoC.getName())) {
Assertions.assertNotNull(rcC);
- snapC = (OmSnapshot) rcC.get();
+ snapC = rcC.get();
}
// assert that key a is in snapshot c's deleted table
@@ -287,12 +284,11 @@ public void testSnapshotAndKeyDeletionBackgroundServices()
// get snapshot d
OmSnapshot snapD;
- try (ReferenceCounted rcD = newLeaderOM
+ try (ReferenceCounted rcD = newLeaderOM
.getOmSnapshotManager()
- .checkForSnapshot(volumeName, bucketName,
- getSnapshotPrefix(snapshotInfoD.getName()), true)) {
+ .getSnapshot(volumeName, bucketName, snapshotInfoD.getName())) {
Assertions.assertNotNull(rcD);
- snapD = (OmSnapshot) rcD.get();
+ snapD = rcD.get();
}
// wait until key a appears in deleted table of snapshot d
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotDeletingService.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotDeletingService.java
index 843a955ecde0..785ae8c25df5 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotDeletingService.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestSnapshotDeletingService.java
@@ -39,7 +39,6 @@
import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
import org.apache.hadoop.ozone.om.service.SnapshotDeletingService;
import org.apache.hadoop.ozone.om.snapshot.ReferenceCounted;
-import org.apache.hadoop.ozone.om.snapshot.SnapshotCache;
import org.apache.ozone.test.GenericTestUtils;
import org.apache.ozone.test.tag.Flaky;
import org.junit.jupiter.api.AfterEach;
@@ -59,7 +58,6 @@
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_CHUNK_SIZE_KEY;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_ACL_ENABLED;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_BLOCK_DELETING_SERVICE_INTERVAL;
-import static org.apache.hadoop.ozone.om.OmSnapshotManager.getSnapshotPrefix;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_SNAPSHOT_DELETING_SERVICE_INTERVAL;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_SNAPSHOT_DELETING_SERVICE_TIMEOUT;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -134,9 +132,8 @@ public void testSnapshotSplitAndMove() throws Exception {
GenericTestUtils.waitFor(() -> snapshotDeletingService
.getSuccessfulRunCount() >= 1, 1000, 10000);
- OmSnapshot bucket1snap3 = (OmSnapshot) om.getOmSnapshotManager()
- .checkForSnapshot(VOLUME_NAME, BUCKET_NAME_ONE,
- getSnapshotPrefix("bucket1snap3"), true).get();
+ OmSnapshot bucket1snap3 = om.getOmSnapshotManager()
+ .getSnapshot(VOLUME_NAME, BUCKET_NAME_ONE, "bucket1snap3").get();
// Check bucket1key1 added to next non deleted snapshot db.
List> omKeyInfos =
@@ -192,8 +189,7 @@ public void testMultipleSnapshotKeyReclaim() throws Exception {
// verify the cache of purged snapshot
// /vol1/bucket2/bucket2snap1 has been cleaned up from cache map
- SnapshotCache snapshotCache = om.getOmSnapshotManager().getSnapshotCache();
- assertEquals(2, snapshotCache.size());
+ assertEquals(2, om.getOmSnapshotManager().getSnapshotCacheSize());
}
@SuppressWarnings("checkstyle:MethodLength")
@@ -362,9 +358,8 @@ public void testSnapshotWithFSO() throws Exception {
assertTableRowCount(om.getMetadataManager().getSnapshotInfoTable(), 2);
verifySnapshotChain(deletedSnap, "/vol1/bucket2/snap3");
- OmSnapshot snap3 = (OmSnapshot) om.getOmSnapshotManager()
- .checkForSnapshot(VOLUME_NAME, BUCKET_NAME_TWO,
- getSnapshotPrefix("snap3"), true).get();
+ OmSnapshot snap3 = om.getOmSnapshotManager()
+ .getSnapshot(VOLUME_NAME, BUCKET_NAME_TWO, "snap3").get();
Table snapDeletedDirTable =
snap3.getMetadataManager().getDeletedDirTable();
@@ -391,10 +386,10 @@ public void testSnapshotWithFSO() throws Exception {
assertTableRowCount(renamedTable, 4);
assertTableRowCount(deletedDirTable, 3);
- ReferenceCounted rcSnap1 =
- om.getOmSnapshotManager().checkForSnapshot(
- VOLUME_NAME, BUCKET_NAME_TWO, getSnapshotPrefix("snap1"), true);
- OmSnapshot snap1 = (OmSnapshot) rcSnap1.get();
+ ReferenceCounted rcSnap1 =
+ om.getOmSnapshotManager().getSnapshot(
+ VOLUME_NAME, BUCKET_NAME_TWO, "snap1");
+ OmSnapshot snap1 = rcSnap1.get();
Table snap1KeyTable =
snap1.getMetadataManager().getFileTable();
try (TableIterator keyMetadataList = data.getKeys();
+
+ assertEquals(1, data.getTotalCount());
+ assertEquals(1, keyMetadataList.size());
+
+ // Assert the file name and the complete path.
+ KeyMetadata keyMetadata = keyMetadataList.iterator().next();
+ assertEquals("file1", keyMetadata.getKey());
+ assertEquals("testvol/fsobucket/dir1/dir2/dir3/file1", keyMetadata.getCompletePath());
+
+ testContainerID = 2L;
+ response = getContainerEndpointResponse(testContainerID);
+ data = (KeysResponse) response.getEntity();
+ keyMetadataList = data.getKeys();
+ assertEquals(1, data.getTotalCount());
+ assertEquals(1, keyMetadataList.size());
+
+ // Assert the file name and the complete path.
+ keyMetadata = keyMetadataList.iterator().next();
+ assertEquals("file1", keyMetadata.getKey());
+ assertEquals("testvol/fsobucket/file1", keyMetadata.getCompletePath());
+ }
+
+ @Test
+ public void testContainerEndpointForOBSBucket() throws Exception {
+ String volumeName = "testvol2";
+ String obsBucketName = "obsbucket";
+ String obsSingleFileKey = "file1";
+
+ // Setup volume and OBS bucket
+ store.createVolume(volumeName);
+ OzoneVolume volume = store.getVolume(volumeName);
+ volume.createBucket(obsBucketName,
+ BucketArgs.newBuilder().setBucketLayout(BucketLayout.OBJECT_STORE)
+ .build());
+
+ // Write a single file to the OBS bucket
+ writeTestData(volumeName, obsBucketName, obsSingleFileKey, "Hello OBS!");
+
+ OzoneManagerServiceProviderImpl impl =
+ (OzoneManagerServiceProviderImpl) cluster.getReconServer()
+ .getOzoneManagerServiceProvider();
+ impl.syncDataFromOM();
+
+ // Search for the bucket from the bucket table and verify its OBS
+ OmBucketInfo bucketInfo = cluster.getOzoneManager().getBucketInfo(volumeName, obsBucketName);
+ assertNotNull(bucketInfo);
+ assertEquals(BucketLayout.OBJECT_STORE, bucketInfo.getBucketLayout());
+
+ // Initialize the ContainerEndpoint
+ long containerId = 1L;
+ Response response = getContainerEndpointResponse(containerId);
+
+ assertNotNull(response, "Response should not be null.");
+ assertEquals(Response.Status.OK.getStatusCode(), response.getStatus(),
+ "Expected HTTP 200 OK response.");
+ KeysResponse data = (KeysResponse) response.getEntity();
+ Collection keyMetadataList = data.getKeys();
+
+ assertEquals(1, data.getTotalCount());
+ assertEquals(1, keyMetadataList.size());
+
+ KeyMetadata keyMetadata = keyMetadataList.iterator().next();
+ assertEquals("file1", keyMetadata.getKey());
+ assertEquals("testvol2/obsbucket/file1", keyMetadata.getCompletePath());
+ }
+
+ private Response getContainerEndpointResponse(long containerId) {
+ OzoneStorageContainerManager reconSCM =
+ cluster.getReconServer().getReconStorageContainerManager();
+ ReconContainerManager reconContainerManager =
+ (ReconContainerManager) reconSCM.getContainerManager();
+ ContainerHealthSchemaManager containerHealthSchemaManager =
+ reconContainerManager.getContainerSchemaManager();
+ ReconOMMetadataManager omMetadataManagerInstance =
+ (ReconOMMetadataManager)
+ cluster.getReconServer().getOzoneManagerServiceProvider()
+ .getOMMetadataManagerInstance();
+ ContainerEndpoint containerEndpoint =
+ new ContainerEndpoint(reconSCM, containerHealthSchemaManager,
+ cluster.getReconServer().getReconNamespaceSummaryManager(),
+ cluster.getReconServer().getReconContainerMetadataManager(),
+ omMetadataManagerInstance);
+ return containerEndpoint.getKeysForContainer(containerId, 10, "");
+ }
+
+ private void writeTestData(String volumeName, String bucketName,
+ String keyPath, String data) throws Exception {
+ try (OzoneOutputStream out = client.getObjectStore().getVolume(volumeName)
+ .getBucket(bucketName)
+ .createKey(keyPath, data.length())) {
+ out.write(data.getBytes(StandardCharsets.UTF_8));
+ }
+ }
+
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientGrpc.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientGrpc.java
index ae156be8a482..5dd6320c1d4d 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientGrpc.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientGrpc.java
@@ -202,11 +202,11 @@ public XceiverClientReply sendCommandAsync(
private void invokeXceiverClientGetBlock(XceiverClientSpi client)
throws IOException {
ContainerProtocolCalls.getBlock(client,
- ContainerProtos.DatanodeBlockID.newBuilder()
+ BlockID.getFromProtobuf(ContainerProtos.DatanodeBlockID.newBuilder()
.setContainerID(1)
.setLocalID(1)
.setBlockCommitSequenceId(1)
- .build(), null);
+ .build()), null, client.getPipeline().getReplicaIndexes());
}
private void invokeXceiverClientReadChunk(XceiverClientSpi client)
@@ -223,7 +223,7 @@ private void invokeXceiverClientReadChunk(XceiverClientSpi client)
.setLen(-1)
.setOffset(0)
.build(),
- bid,
+ bid.getDatanodeBlockIDProtobuf(),
null, null);
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMDBCheckpointServlet.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMDBCheckpointServlet.java
index 65584d705852..edfe7ffd87d1 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMDBCheckpointServlet.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMDBCheckpointServlet.java
@@ -27,6 +27,7 @@
import org.apache.hadoop.hdds.utils.DBCheckpointServlet;
import org.apache.hadoop.hdds.utils.db.DBCheckpoint;
import org.apache.hadoop.hdds.utils.db.RDBCheckpointUtils;
+import org.apache.hadoop.hdds.utils.db.RDBStore;
import org.apache.hadoop.hdds.utils.db.Table;
import org.apache.hadoop.hdds.utils.db.TableIterator;
import org.apache.hadoop.ozone.OzoneConsts;
@@ -317,8 +318,7 @@ private boolean getFilesForArchive(DBCheckpoint checkpoint,
// Get the snapshot files.
Set snapshotPaths = waitForSnapshotDirs(checkpoint);
- Path snapshotDir = Paths.get(OMStorage.getOmDbDir(getConf()).toString(),
- OM_SNAPSHOT_DIR);
+ Path snapshotDir = getSnapshotDir();
if (!processDir(snapshotDir, copyFiles, hardLinkFiles, sstFilesToExclude,
snapshotPaths, excluded, copySize, null)) {
return false;
@@ -635,6 +635,15 @@ private OzoneConfiguration getConf() {
.getConfiguration();
}
+ private Path getSnapshotDir() {
+ OzoneManager om = (OzoneManager) getServletContext().getAttribute(OzoneConsts.OM_CONTEXT_ATTRIBUTE);
+ RDBStore store = (RDBStore) om.getMetadataManager().getStore();
+ // store.getSnapshotsParentDir() returns path to checkpointState (e.g. /db.snapshots/checkpointState)
+ // But we need to return path till db.snapshots which contains checkpointState and diffState.
+ // So that whole snapshots and compaction information can be transferred to follower.
+ return Paths.get(store.getSnapshotsParentDir()).getParent();
+ }
+
@Override
public BootstrapStateHandler.Lock getBootstrapStateLock() {
return lock;
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java
index faf0efd46433..7003f818bf1a 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OMMetrics.java
@@ -26,6 +26,7 @@
import org.apache.hadoop.metrics2.annotation.Metrics;
import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
import org.apache.hadoop.metrics2.lib.MutableCounterLong;
+import org.apache.hadoop.metrics2.lib.MutableGaugeInt;
/**
* This class is for maintaining Ozone Manager statistics.
@@ -77,6 +78,7 @@ public class OMMetrics implements OmMetadataReaderMetrics {
private @Metric MutableCounterLong numSnapshotPurges;
private @Metric MutableCounterLong numSnapshotSetProperties;
+ private @Metric MutableGaugeInt numSnapshotCacheSize;
private @Metric MutableCounterLong numGetFileStatus;
private @Metric MutableCounterLong numCreateDirectory;
private @Metric MutableCounterLong numCreateFile;
@@ -541,6 +543,17 @@ public void decNumSnapshotDeleted() {
numSnapshotDeleted.incr(-1);
}
+ public int getNumSnapshotCacheSize() {
+ return numSnapshotCacheSize.value();
+ }
+ public void incNumSnapshotCacheSize() {
+ numSnapshotCacheSize.incr();
+ }
+
+ public void decNumSnapshotCacheSize() {
+ numSnapshotCacheSize.decr();
+ }
+
public void incNumCompleteMultipartUploadFails() {
numCompleteMultipartUploadFails.incr();
}
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
index 56ad604922ad..dd7e749b3e32 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmMetadataManagerImpl.java
@@ -88,7 +88,6 @@
import org.apache.hadoop.ozone.om.protocolPB.OzoneManagerProtocolClientSideTranslatorPB;
import org.apache.hadoop.ozone.om.request.util.OMMultipartUploadUtils;
import org.apache.hadoop.ozone.om.snapshot.ReferenceCounted;
-import org.apache.hadoop.ozone.om.snapshot.SnapshotCache;
import org.apache.hadoop.ozone.om.snapshot.SnapshotUtils;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.ExpiredMultipartUploadInfo;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos.ExpiredMultipartUploadsBucket;
@@ -108,7 +107,6 @@
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_FS_SNAPSHOT_MAX_LIMIT_DEFAULT;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_SNAPSHOT_CHECKPOINT_DIR_CREATION_POLL_TIMEOUT;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_SNAPSHOT_CHECKPOINT_DIR_CREATION_POLL_TIMEOUT_DEFAULT;
-import static org.apache.hadoop.ozone.om.OmSnapshotManager.getSnapshotPrefix;
import static org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.BUCKET_NOT_FOUND;
import static org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.FILE_NOT_FOUND;
import static org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.VOLUME_NOT_FOUND;
@@ -1537,7 +1535,7 @@ public PendingKeysDeletion getPendingDeletionKeys(final int keyCount,
OmBucketInfo bucketInfo = getBucketTable().get(bucketKey);
// Get the latest snapshot in snapshot path.
- try (ReferenceCounted
+ try (ReferenceCounted
rcLatestSnapshot = getLatestActiveSnapshot(
keySplit[1], keySplit[2], omSnapshotManager)) {
@@ -1555,13 +1553,12 @@ public PendingKeysDeletion getPendingDeletionKeys(final int keyCount,
if (rcLatestSnapshot != null) {
Table prevKeyTable =
- ((OmSnapshot) rcLatestSnapshot.get())
+ rcLatestSnapshot.get()
.getMetadataManager()
.getKeyTable(bucketInfo.getBucketLayout());
Table prevDeletedTable =
- ((OmSnapshot) rcLatestSnapshot.get())
- .getMetadataManager().getDeletedTable();
+ rcLatestSnapshot.get().getMetadataManager().getDeletedTable();
String prevKeyTableDBKey = getSnapshotRenamedTable()
.get(dbRenameKey);
String prevDelTableDBKey = getOzoneKey(info.getVolumeName(),
@@ -1647,8 +1644,7 @@ private boolean versionExistsInPreviousSnapshot(OmKeyInfo omKeyInfo,
/**
* Get the latest OmSnapshot for a snapshot path.
*/
- public ReferenceCounted<
- IOmMetadataReader, SnapshotCache> getLatestActiveSnapshot(
+ public ReferenceCounted getLatestActiveSnapshot(
String volumeName, String bucketName,
OmSnapshotManager snapshotManager)
throws IOException {
@@ -1682,13 +1678,12 @@ IOmMetadataReader, SnapshotCache> getLatestActiveSnapshot(
}
}
- Optional> rcOmSnapshot =
+ Optional> rcOmSnapshot =
snapshotInfo.isPresent() ?
Optional.ofNullable(
- snapshotManager.checkForSnapshot(volumeName,
+ snapshotManager.getSnapshot(volumeName,
bucketName,
- getSnapshotPrefix(snapshotInfo.get().getName()),
- true)
+ snapshotInfo.get().getName())
) :
Optional.empty();
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java
index 5839c61cf31f..f863c086028e 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshot.java
@@ -47,6 +47,7 @@
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.UUID;
import java.util.stream.Collectors;
/**
@@ -74,6 +75,7 @@ public class OmSnapshot implements IOmMetadataReader, Closeable {
private final String volumeName;
private final String bucketName;
private final String snapshotName;
+ private final UUID snapshotID;
// To access snapshot checkpoint DB metadata
private final OMMetadataManager omMetadataManager;
private final KeyManager keyManager;
@@ -83,7 +85,8 @@ public OmSnapshot(KeyManager keyManager,
OzoneManager ozoneManager,
String volumeName,
String bucketName,
- String snapshotName) {
+ String snapshotName,
+ UUID snapshotID) {
IAccessAuthorizer accessAuthorizer =
OzoneAuthorizerFactory.forSnapshot(ozoneManager,
keyManager, prefixManager);
@@ -93,6 +96,7 @@ public OmSnapshot(KeyManager keyManager,
this.snapshotName = snapshotName;
this.bucketName = bucketName;
this.volumeName = volumeName;
+ this.snapshotID = snapshotID;
this.keyManager = keyManager;
this.omMetadataManager = keyManager.getMetadataManager();
}
@@ -295,6 +299,10 @@ public String getName() {
return snapshotName;
}
+ public UUID getSnapshotID() {
+ return snapshotID;
+ }
+
@Override
public void close() throws IOException {
// Close DB
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
index 6e9af3960cae..9d8352d2834f 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OmSnapshotManager.java
@@ -35,6 +35,7 @@
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
+import java.util.UUID;
import com.google.common.cache.RemovalListener;
import org.apache.hadoop.hdds.StringUtils;
@@ -82,6 +83,8 @@
import static org.apache.hadoop.ozone.OzoneConsts.OM_SNAPSHOT_CHECKPOINT_DIR;
import static org.apache.hadoop.ozone.OzoneConsts.OM_SNAPSHOT_DIFF_DB_NAME;
import static org.apache.hadoop.ozone.OzoneConsts.OM_SNAPSHOT_INDICATOR;
+import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_CACHE_CLEANUP_SERVICE_RUN_INTERVAL;
+import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_CACHE_CLEANUP_SERVICE_RUN_INTERVAL_DEFAULT;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_CACHE_MAX_SIZE;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_CACHE_MAX_SIZE_DEFAULT;
import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_DB_MAX_OPEN_FILES;
@@ -244,7 +247,7 @@ public OmSnapshotManager(OzoneManager ozoneManager) {
OZONE_OM_SNAPSHOT_CACHE_MAX_SIZE,
OZONE_OM_SNAPSHOT_CACHE_MAX_SIZE_DEFAULT);
- CacheLoader loader = createCacheLoader();
+ CacheLoader loader = createCacheLoader();
// TODO: [SNAPSHOT] Remove this if not going to make SnapshotCache impl
// pluggable.
@@ -271,10 +274,15 @@ public OmSnapshotManager(OzoneManager ozoneManager) {
};
// Init snapshot cache
- this.snapshotCache = new SnapshotCache(this, loader, softCacheSize);
+ long cacheCleanupServiceInterval = ozoneManager.getConfiguration()
+ .getTimeDuration(OZONE_OM_SNAPSHOT_CACHE_CLEANUP_SERVICE_RUN_INTERVAL,
+ OZONE_OM_SNAPSHOT_CACHE_CLEANUP_SERVICE_RUN_INTERVAL_DEFAULT,
+ TimeUnit.MILLISECONDS);
+ this.snapshotCache = new SnapshotCache(loader, softCacheSize, ozoneManager.getMetrics(),
+ cacheCleanupServiceInterval);
this.snapshotDiffManager = new SnapshotDiffManager(snapshotDiffDb, differ,
- ozoneManager, snapshotCache, snapDiffJobCf, snapDiffReportCf,
+ ozoneManager, snapDiffJobCf, snapDiffReportCf,
columnFamilyOptions, codecRegistry);
diffCleanupServiceInterval = ozoneManager.getConfiguration()
@@ -325,19 +333,25 @@ public boolean canDisableFsSnapshot(OMMetadataManager ommm) {
return isSnapshotInfoTableEmpty;
}
- private CacheLoader createCacheLoader() {
- return new CacheLoader() {
+ private CacheLoader createCacheLoader() {
+ return new CacheLoader() {
@Nonnull
@Override
- public OmSnapshot load(@Nonnull String snapshotTableKey)
- throws IOException {
- // Check if the snapshot exists
- final SnapshotInfo snapshotInfo = getSnapshotInfo(snapshotTableKey);
+ public OmSnapshot load(@Nonnull UUID snapshotId) throws IOException {
+ String snapshotTableKey = ((OmMetadataManagerImpl) ozoneManager.getMetadataManager())
+ .getSnapshotChainManager()
+ .getTableKey(snapshotId);
+
+ // SnapshotChain maintains in-memory reverse mapping of snapshotId to snapshotName based on snapshotInfoTable.
+ // So it should not happen ideally.
+ // If it happens, then either snapshot has been purged in between or SnapshotChain is corrupted
+ // and missing some entries which needs investigation.
+ if (snapshotTableKey == null) {
+ throw new IOException("No snapshot exist with snapshotId: " + snapshotId);
+ }
- // Block snapshot from loading when it is no longer active e.g. DELETED,
- // unless this is called from SnapshotDeletingService.
- checkSnapshotActive(snapshotInfo, true);
+ final SnapshotInfo snapshotInfo = getSnapshotInfo(snapshotTableKey);
CacheValue cacheValue = ozoneManager.getMetadataManager()
.getSnapshotInfoTable()
@@ -375,7 +389,8 @@ public OmSnapshot load(@Nonnull String snapshotTableKey)
return new OmSnapshot(km, pm, ozoneManager,
snapshotInfo.getVolumeName(),
snapshotInfo.getBucketName(),
- snapshotInfo.getName());
+ snapshotInfo.getName(),
+ snapshotInfo.getSnapshotId());
} catch (Exception e) {
// Close RocksDB if there is any failure.
if (!snapshotMetadataManager.getStore().isClosed()) {
@@ -397,11 +412,32 @@ private static CodecRegistry createCodecRegistryForSnapDiff() {
}
/**
- * Get snapshot instance LRU cache.
- * @return LoadingCache
+ * Get snapshot instance LRU cache size.
+ * @return cache size.
*/
- public SnapshotCache getSnapshotCache() {
- return snapshotCache;
+ @VisibleForTesting
+ public int getSnapshotCacheSize() {
+ return snapshotCache == null ? 0 : snapshotCache.size();
+ }
+
+ /**
+ * Immediately invalidate all entries and close their DB instances in cache.
+ */
+ public void invalidateCache() {
+ if (snapshotCache != null) {
+ snapshotCache.invalidateAll();
+ }
+ }
+
+ /**
+ * Immediately invalidate an entry.
+ *
+ * @param key SnapshotId.
+ */
+ public void invalidateCacheEntry(UUID key) {
+ if (snapshotCache != null) {
+ snapshotCache.invalidate(key);
+ }
}
/**
@@ -590,11 +626,11 @@ private static void deleteKeysFromDelKeyTableInSnapshotScope(
}
// Get OmSnapshot if the keyName has ".snapshot" key indicator
- public ReferenceCounted