From 82cf855e399e7343e2493e5ff9f1a0af87899493 Mon Sep 17 00:00:00 2001
From: "Doroszlai, Attila" <6454655+adoroszlai@users.noreply.github.com>
Date: Fri, 12 Jan 2024 13:03:12 +0800
Subject: [PATCH 1/9] HDDS-10115. Migrate MetricsAsserts to AssertJ (#5987)

(cherry picked from commit f42334b2175430d6186ef4f4011d42963265a900)
---
 hadoop-hdds/test-utils/pom.xml                |  20 +
 .../org/apache/ozone/test/MetricsAsserts.java | 470 ++++++++++++++++++
 .../server/ratis/TestCSMMetrics.java          |   6 +-
 .../metrics/TestContainerMetrics.java         |   5 +-
 .../metrics/TestDatanodeQueueMetrics.java     |   4 +-
 ...estSCMContainerPlacementPolicyMetrics.java |   2 +-
 .../ozone/scm/TestXceiverClientMetrics.java   |   6 +-
 .../scm/pipeline/TestSCMPipelineMetrics.java  |  15 +-
 8 files changed, 509 insertions(+), 19 deletions(-)
 create mode 100644 hadoop-hdds/test-utils/src/main/java/org/apache/ozone/test/MetricsAsserts.java

diff --git a/hadoop-hdds/test-utils/pom.xml b/hadoop-hdds/test-utils/pom.xml
index 0dde6c013137..bf6d81a04e0a 100644
--- a/hadoop-hdds/test-utils/pom.xml
+++ b/hadoop-hdds/test-utils/pom.xml
@@ -33,6 +33,10 @@ https://maven.apache.org/xsd/maven-4.0.0.xsd">
   </properties>
 
   <dependencies>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+    </dependency>
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
@@ -66,6 +70,17 @@ https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.hadoop</groupId>
+      <artifactId>hadoop-common</artifactId>
+      <scope>provided</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>*</groupId>
+          <artifactId>*</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
     <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-api</artifactId>
@@ -85,6 +100,11 @@ https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <artifactId>mockito-core</artifactId>
       <scope>provided</scope>
     </dependency>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <scope>compile</scope>
+    </dependency>
   </dependencies>
 
 </project>
diff --git a/hadoop-hdds/test-utils/src/main/java/org/apache/ozone/test/MetricsAsserts.java b/hadoop-hdds/test-utils/src/main/java/org/apache/ozone/test/MetricsAsserts.java
new file mode 100644
index 000000000000..28d3b936ecab
--- /dev/null
+++ b/hadoop-hdds/test-utils/src/main/java/org/apache/ozone/test/MetricsAsserts.java
@@ -0,0 +1,470 @@
+/*
+ * 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.ozone.test;
+
+import static org.apache.hadoop.metrics2.lib.Interns.info;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.AdditionalMatchers.geq;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.hadoop.metrics2.MetricsInfo;
+import org.apache.hadoop.metrics2.MetricsCollector;
+import org.apache.hadoop.metrics2.MetricsSource;
+import org.apache.hadoop.metrics2.MetricsRecordBuilder;
+import org.apache.hadoop.metrics2.MetricsSystem;
+import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
+import org.apache.hadoop.metrics2.lib.MutableQuantiles;
+import org.apache.hadoop.metrics2.util.Quantile;
+import org.assertj.core.data.Offset;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.stubbing.Answer;
+import org.mockito.invocation.InvocationOnMock;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Objects;
+
+/**
+ * Helpers for metrics source tests.
+ */
+public final class MetricsAsserts {
+
+  private static final Logger LOG = LoggerFactory.getLogger(MetricsAsserts.class);
+  private static final Offset<Double> EPSILON = Offset.offset(0.00001);
+  private static final Offset<Float> EPSILON_FLOAT = Offset.offset(0.00001f);
+
+  public static MetricsSystem mockMetricsSystem() {
+    MetricsSystem ms = mock(MetricsSystem.class);
+    DefaultMetricsSystem.setInstance(ms);
+    return ms;
+  }
+
+  public static MetricsRecordBuilder mockMetricsRecordBuilder() {
+    final MetricsCollector mc = mock(MetricsCollector.class);
+    MetricsRecordBuilder rb = mock(MetricsRecordBuilder.class, new Answer<Object>() {
+      @Override
+      public Object answer(InvocationOnMock invocation) {
+        String methodName = invocation.getMethod().getName();
+        if (LOG.isDebugEnabled()) {
+          Object[] args = invocation.getArguments();
+          StringBuilder sb = new StringBuilder();
+          for (Object o : args) {
+            if (sb.length() > 0) {
+              sb.append(", ");
+            }
+            sb.append(String.valueOf(o));
+          }
+          LOG.debug("{}: {}", methodName, sb);
+        }
+        return methodName.equals("parent") || methodName.equals("endRecord") ?
+               mc : invocation.getMock();
+      }
+    });
+    when(mc.addRecord(anyString())).thenReturn(rb);
+    when(mc.addRecord(anyInfo())).thenReturn(rb);
+    return rb;
+  }
+
+  /**
+   * Call getMetrics on source and get a record builder mock to verify.
+   * @param source  the metrics source
+   * @param all     if true, return all metrics even if not changed
+   * @return the record builder mock to verifyÏ
+   */
+  public static MetricsRecordBuilder getMetrics(MetricsSource source,
+                                                boolean all) {
+    MetricsRecordBuilder rb = mockMetricsRecordBuilder();
+    MetricsCollector mc = rb.parent();
+    source.getMetrics(mc, all);
+    return rb;
+  }
+
+  public static MetricsRecordBuilder getMetrics(String name) {
+    return getMetrics(DefaultMetricsSystem.instance().getSource(name));
+  }
+
+  public static MetricsRecordBuilder getMetrics(MetricsSource source) {
+    return getMetrics(source, true);
+  }
+
+  private static class InfoWithSameName implements ArgumentMatcher<MetricsInfo> {
+    private final String expected;
+
+    InfoWithSameName(MetricsInfo info) {
+      expected = Objects.requireNonNull(info.name(), "info name");
+    }
+
+    @Override
+    public boolean matches(MetricsInfo info) {
+      return expected.equals(info.name());
+    }
+
+    @Override
+    public String toString() {
+      return "Info with name=" + expected;
+    }
+  }
+
+  /**
+   * MetricInfo with the same name.
+   * @param info to match
+   * @return <code>null</code>
+   */
+  public static MetricsInfo eqName(MetricsInfo info) {
+    return argThat(new InfoWithSameName(info));
+  }
+
+  private static class AnyInfo implements ArgumentMatcher<MetricsInfo> {
+    @Override
+    public boolean matches(MetricsInfo info) {
+      return info != null;
+    }
+  }
+
+  public static MetricsInfo anyInfo() {
+    return argThat(new AnyInfo());
+  }
+
+  /**
+   * Assert an int gauge metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertGauge(String name, int expected,
+                                 MetricsRecordBuilder rb) {
+    assertThat(getIntGauge(name, rb)).as(name)
+        .isEqualTo(expected);
+  }
+
+  public static int getIntGauge(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(Integer.class);
+    verify(rb, atLeast(0)).addGauge(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+  /**
+   * Assert an int counter metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertCounter(String name, int expected,
+                                   MetricsRecordBuilder rb) {
+    assertThat(getIntCounter(name, rb)).as(name)
+        .isEqualTo(expected);
+  }
+
+  public static int getIntCounter(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<Integer> captor = ArgumentCaptor.forClass(
+        Integer.class);
+    verify(rb, atLeast(0)).addCounter(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+  
+  /**
+   * Assert a long gauge metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertGauge(String name, long expected,
+                                 MetricsRecordBuilder rb) {
+    assertThat(getLongGauge(name, rb)).as(name)
+        .isEqualTo(expected);
+  }
+
+  public static long getLongGauge(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+    verify(rb, atLeast(0)).addGauge(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+   /**
+   * Assert a double gauge metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertGauge(String name, double expected, MetricsRecordBuilder rb) {
+    assertThat(getDoubleGauge(name, rb)).as(name)
+        .isCloseTo(expected, EPSILON);
+  }
+
+  public static double getDoubleGauge(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<Double> captor = ArgumentCaptor.forClass(Double.class);
+    verify(rb, atLeast(0)).addGauge(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+  /**
+   * Assert a long counter metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertCounter(String name, long expected,
+                                   MetricsRecordBuilder rb) {
+    assertThat(getLongCounter(name, rb)).as(name)
+        .isEqualTo(expected);
+  }
+
+  public static long getLongCounter(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+    verify(rb, atLeast(0)).addCounter(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+  public static long getLongCounterWithoutCheck(String name,
+      MetricsRecordBuilder rb) {
+    ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+    verify(rb, atLeast(0)).addCounter(eqName(info(name, "")), captor.capture());
+    return captor.getValue();
+  }
+
+  public static String getStringMetric(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+    verify(rb, atLeast(0)).tag(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+   /**
+   * Assert a float gauge metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertGauge(String name, float expected,
+      MetricsRecordBuilder rb) {
+    assertThat(getFloatGauge(name, rb)).as(name)
+        .isCloseTo(expected, EPSILON_FLOAT);
+  }
+
+  public static float getFloatGauge(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<Float> captor = ArgumentCaptor.forClass(Float.class);
+    verify(rb, atLeast(0)).addGauge(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+  /**
+   * Check that this metric was captured exactly once.
+   */
+  private static void checkCaptured(ArgumentCaptor<?> captor, String name) {
+    assertThat(captor.getAllValues()).as(name)
+        .hasSize(1);
+  }
+
+  /**
+   * Assert an int gauge metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param source  to get metrics from
+   */
+  public static void assertGauge(String name, int expected,
+                                 MetricsSource source) {
+    assertGauge(name, expected, getMetrics(source));
+  }
+
+  /**
+   * Assert an int counter metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param source  to get metrics from
+   */
+  public static void assertCounter(String name, int expected,
+                                   MetricsSource source) {
+    assertCounter(name, expected, getMetrics(source));
+  }
+
+  /**
+   * Assert a long gauge metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param source  to get metrics from
+   */
+  public static void assertGauge(String name, long expected,
+                                 MetricsSource source) {
+    assertGauge(name, expected, getMetrics(source));
+  }
+
+  /**
+   * Assert a long counter metric as expected.
+   * @param name  of the metric
+   * @param expected  value of the metric
+   * @param source  to get metrics from
+   */
+  public static void assertCounter(String name, long expected,
+                                   MetricsSource source) {
+    assertCounter(name, expected, getMetrics(source));
+  }
+
+  /**
+   * Assert that a long counter metric is greater than a value.
+   * @param name  of the metric
+   * @param greater value of the metric should be greater than this
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertCounterGt(String name, long greater,
+                                     MetricsRecordBuilder rb) {
+    assertThat(getLongCounter(name, rb)).as(name)
+        .isGreaterThan(greater);
+  }
+
+  /**
+   * Assert that a long counter metric is greater than a value.
+   * @param name  of the metric
+   * @param greater value of the metric should be greater than this
+   * @param source  the metrics source
+   */
+  public static void assertCounterGt(String name, long greater,
+                                     MetricsSource source) {
+    assertCounterGt(name, greater, getMetrics(source));
+  }
+
+  /**
+   * Assert that a double gauge metric is greater than a value.
+   * @param name  of the metric
+   * @param greater value of the metric should be greater than this
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertGaugeGt(String name, double greater,
+                                   MetricsRecordBuilder rb) {
+    assertThat(getDoubleGauge(name, rb)).as(name)
+        .isGreaterThan(greater);
+  }
+
+  /**
+   * Assert that a double gauge metric is greater than or equal to a value.
+   * @param name  of the metric
+   * @param greater value of the metric should be greater than or equal to this
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertGaugeGte(String name, double greater,
+      MetricsRecordBuilder rb) {
+    double curValue = getDoubleGauge(name, rb);
+    assertThat(curValue).as(name)
+        .isGreaterThanOrEqualTo(greater);
+  }
+
+  /**
+   * Assert that a double gauge metric is greater than a value.
+   * @param name  of the metric
+   * @param greater value of the metric should be greater than this
+   * @param source  the metrics source
+   */
+  public static void assertGaugeGt(String name, double greater,
+                                   MetricsSource source) {
+    assertGaugeGt(name, greater, getMetrics(source));
+  }
+  
+  /**
+   * Asserts that the NumOps and quantiles for a metric with value name
+   * "Latency" have been changed at some point to a non-zero value.
+   * 
+   * @param prefix of the metric
+   * @param rb MetricsRecordBuilder with the metric
+   */
+  public static void assertQuantileGauges(String prefix,
+      MetricsRecordBuilder rb) {
+    assertQuantileGauges(prefix, rb, "Latency");
+  }
+
+  /**
+   * Asserts that the NumOps and quantiles for a metric have been changed at
+   * some point to a non-zero value, for the specified value name of the
+   * metrics (e.g., "Latency", "Count").
+   *
+   * @param prefix of the metric
+   * @param rb MetricsRecordBuilder with the metric
+   * @param valueName the value name for the metric
+   */
+  public static void assertQuantileGauges(String prefix,
+      MetricsRecordBuilder rb, String valueName) {
+    verify(rb).addGauge(eqName(info(prefix + "NumOps", "")), geq(0L));
+    for (Quantile q : MutableQuantiles.quantiles) {
+      String nameTemplate = prefix + "%dthPercentile" + valueName;
+      int percentile = (int) (100 * q.quantile);
+      verify(rb).addGauge(
+          eqName(info(String.format(nameTemplate, percentile), "")),
+          geq(0L));
+    }
+  }
+
+  /**
+   * Asserts that the NumOps and inverse quantiles for a metric have been changed at
+   * some point to a non-zero value, for the specified value name of the
+   * metrics (e.g., "Rate").
+   *
+   * @param prefix of the metric
+   * @param rb MetricsRecordBuilder with the metric
+   * @param valueName the value name for the metric
+   */
+  public static void assertInverseQuantileGauges(String prefix,
+      MetricsRecordBuilder rb, String valueName) {
+    verify(rb).addGauge(eqName(info(prefix + "NumOps", "")), geq(0L));
+    for (Quantile q : MutableQuantiles.quantiles) {
+      String nameTemplate = prefix + "%dthInversePercentile" + valueName;
+      int percentile = (int) (100 * q.quantile);
+      verify(rb).addGauge(
+          eqName(info(String.format(nameTemplate, percentile), "")),
+          geq(0L));
+    }
+  }
+
+  /**
+   * Assert a tag of metric as expected.
+   * @param name  of the metric tag
+   * @param expected  value of the metric tag
+   * @param rb  the record builder mock used to getMetrics
+   */
+  public static void assertTag(String name, String expected,
+      MetricsRecordBuilder rb) {
+    assertThat(getStringTag(name, rb)).as("Tag for metric " + name)
+        .isEqualTo(expected);
+  }
+
+  /**
+   * get the value tag for the metric.
+   * @param name  of the metric tag
+   * @param rb value of the metric tag
+   * @return the value tag for the metric
+   */
+  public static String getStringTag(String name, MetricsRecordBuilder rb) {
+    ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+    verify(rb).tag(eqName(info(name, "")), captor.capture());
+    checkCaptured(captor, name);
+    return captor.getValue();
+  }
+
+  private MetricsAsserts() {
+    // no instances
+  }
+}
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java
index cfc10ac34513..db0c785fc647 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java
@@ -18,9 +18,9 @@
 
 package org.apache.hadoop.ozone.container.common.transport.server.ratis;
 
-import static org.apache.hadoop.test.MetricsAsserts.assertCounter;
-import static org.apache.hadoop.test.MetricsAsserts.getDoubleGauge;
-import static org.apache.hadoop.test.MetricsAsserts.getMetrics;
+import static org.apache.ozone.test.MetricsAsserts.assertCounter;
+import static org.apache.ozone.test.MetricsAsserts.getDoubleGauge;
+import static org.apache.ozone.test.MetricsAsserts.getMetrics;
 
 import java.io.File;
 import java.io.IOException;
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
index dd733fa6f82d..cbbbbebe9e13 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
@@ -55,12 +55,13 @@
 import static org.apache.hadoop.test.MetricsAsserts.assertCounter;
 import static org.apache.hadoop.test.MetricsAsserts.assertQuantileGauges;
 import static org.apache.hadoop.test.MetricsAsserts.getMetrics;
+
+import org.apache.ozone.test.JUnit5AwareTimeout;
 import org.junit.Assert;
 import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.junit.rules.TestRule;
 import org.junit.rules.Timeout;
-import org.apache.ozone.test.JUnit5AwareTimeout;
 
 /**
  * Test for metrics published by storage containers.
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestDatanodeQueueMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestDatanodeQueueMetrics.java
index 690f4d9a1e31..ff942d695845 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestDatanodeQueueMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestDatanodeQueueMetrics.java
@@ -39,8 +39,8 @@
 
 import static org.apache.hadoop.ozone.container.common.statemachine.DatanodeQueueMetrics.COMMAND_DISPATCHER_QUEUE_PREFIX;
 import static org.apache.hadoop.ozone.container.common.statemachine.DatanodeQueueMetrics.STATE_CONTEXT_COMMAND_QUEUE_PREFIX;
-import static org.apache.hadoop.test.MetricsAsserts.getLongGauge;
-import static org.apache.hadoop.test.MetricsAsserts.getMetrics;
+import static org.apache.ozone.test.MetricsAsserts.getLongGauge;
+import static org.apache.ozone.test.MetricsAsserts.getMetrics;
 
 /**
  * Test for queue metrics of datanodes.
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestSCMContainerPlacementPolicyMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestSCMContainerPlacementPolicyMetrics.java
index cf8730a9651f..1143230a96bd 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestSCMContainerPlacementPolicyMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestSCMContainerPlacementPolicyMetrics.java
@@ -42,8 +42,8 @@
 import org.apache.hadoop.ozone.client.OzoneVolume;
 import org.apache.hadoop.ozone.client.io.OzoneOutputStream;
 import org.apache.hadoop.ozone.om.OMConfigKeys;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.Assert;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientMetrics.java
index fc4dbfd391b4..42c7a58ccd36 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/TestXceiverClientMetrics.java
@@ -18,9 +18,9 @@
 package org.apache.hadoop.ozone.scm;
 
 import static org.apache.hadoop.hdds.HddsConfigKeys.HDDS_METADATA_DIR_NAME;
-import static org.apache.hadoop.test.MetricsAsserts.assertCounter;
-import static org.apache.hadoop.test.MetricsAsserts.getLongCounter;
-import static org.apache.hadoop.test.MetricsAsserts.getMetrics;
+import static org.apache.ozone.test.MetricsAsserts.assertCounter;
+import static org.apache.ozone.test.MetricsAsserts.getLongCounter;
+import static org.apache.ozone.test.MetricsAsserts.getMetrics;
 
 import java.util.List;
 import java.util.ArrayList;
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/pipeline/TestSCMPipelineMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/pipeline/TestSCMPipelineMetrics.java
index 53f4ce5e16ae..62c31010d25d 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/pipeline/TestSCMPipelineMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/scm/pipeline/TestSCMPipelineMetrics.java
@@ -43,6 +43,8 @@
 import static org.apache.hadoop.test.MetricsAsserts.assertCounter;
 import static org.apache.hadoop.test.MetricsAsserts.getLongCounter;
 import static org.apache.hadoop.test.MetricsAsserts.getMetrics;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /**
  * Test cases to verify the metrics exposed by SCMPipelineManager.
@@ -107,8 +109,8 @@ public void testNumBlocksAllocated() throws IOException, TimeoutException {
     MetricsRecordBuilder metrics =
         getMetrics(SCMPipelineMetrics.class.getSimpleName());
     Pipeline pipeline = block.getPipeline();
-    long numBlocksAllocated = getLongCounter(
-        SCMPipelineMetrics.getBlockAllocationMetricName(pipeline), metrics);
+    final String metricName = SCMPipelineMetrics.getBlockAllocationMetricName(pipeline);
+    long numBlocksAllocated = getLongCounter(metricName, metrics);
     Assertions.assertEquals(numBlocksAllocated, 1);
 
     // destroy the pipeline
@@ -118,12 +120,9 @@ public void testNumBlocksAllocated() throws IOException, TimeoutException {
 
     MetricsRecordBuilder finalMetrics =
         getMetrics(SCMPipelineMetrics.class.getSimpleName());
-    Throwable t = Assertions.assertThrows(AssertionError.class, () ->
-        getLongCounter(SCMPipelineMetrics
-            .getBlockAllocationMetricName(pipeline), finalMetrics));
-    Assertions.assertTrue(t.getMessage().contains(
-        "Expected exactly one metric for name " + SCMPipelineMetrics
-            .getBlockAllocationMetricName(block.getPipeline())));
+    Throwable t = assertThrows(AssertionError.class, () ->
+        getLongCounter(metricName, finalMetrics));
+    assertThat(t).hasMessageContaining(metricName);
   }
 
   @AfterEach

From 2f63c531ba2c04c7516f7d044d944022c11e9acb Mon Sep 17 00:00:00 2001
From: Swaminathan Balachandran <47532440+swamirishi@users.noreply.github.com>
Date: Fri, 23 Feb 2024 06:23:22 +0800
Subject: [PATCH 2/9] HDDS-10149. New JNI layer for RawSSTFileReader &
 RawSSTFileReaderIterator (#6182)

(cherry picked from commit d883d7df4600821f92b884c18ba960976d589138)
---
 .../src/main/resources/ozone-default.xml      |   18 -
 .../db/managed/JniLibNamePropertyWriter.java  |   48 +
 hadoop-hdds/rocks-native/pom.xml              |  210 +---
 hadoop-hdds/rocks-native/src/CMakeLists.txt   |   36 +-
 .../hadoop/hdds/utils/NativeConstants.java    |    3 +-
 .../db/managed/ManagedRawSSTFileIterator.java |  118 ++
 .../db/managed/ManagedRawSSTFileReader.java   |   78 ++
 .../db/managed/ManagedSSTDumpIterator.java    |  314 -----
 .../utils/db/managed/ManagedSSTDumpTool.java  |   99 --
 .../utils/db/managed/PipeInputStream.java     |   88 --
 .../main/native/ManagedRawSSTFileIterator.cpp |   90 ++
 .../main/native/ManagedRawSSTFileReader.cpp   |   65 +
 .../rocks-native/src/main/native/Pipe.cpp     |   37 -
 .../rocks-native/src/main/native/Pipe.h       |   55 -
 .../src/main/native/PipeInputStream.cpp       |   48 -
 .../src/main/native/SSTDumpTool.cpp           |   48 -
 .../main/native/cplusplus_to_java_convert.h   |    2 +-
 .../src/main/patches/rocks-native.patch       | 1085 ++++++++---------
 .../hdds/utils/TestNativeLibraryLoader.java   |   38 +-
 .../TestManagedRawSSTFileIterator.java        |  143 +++
 .../managed/TestManagedSSTDumpIterator.java   |  275 -----
 .../src/test/resources/auditlog.properties    |   76 ++
 .../src/test/resources/log4j.properties       |   23 +
 .../ozone/rocksdb/util/SstFileSetReader.java  |  200 +--
 .../rocksdb/util/TestSstFileSetReader.java    |   62 +-
 .../apache/hadoop/ozone/om/OMConfigKeys.java  |   12 -
 hadoop-ozone/dev-support/checks/native.sh     |   10 +-
 .../om/snapshot/SnapshotDiffManager.java      |   59 +-
 .../om/snapshot/TestSnapshotDiffManager.java  |   43 +-
 pom.xml                                       |   20 +-
 30 files changed, 1408 insertions(+), 1995 deletions(-)
 create mode 100644 hadoop-hdds/managed-rocksdb/src/main/java/org/apache/hadoop/hdds/utils/db/managed/JniLibNamePropertyWriter.java
 create mode 100644 hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileIterator.java
 create mode 100644 hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileReader.java
 delete mode 100644 hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpIterator.java
 delete mode 100644 hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpTool.java
 delete mode 100644 hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/PipeInputStream.java
 create mode 100644 hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileIterator.cpp
 create mode 100644 hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileReader.cpp
 delete mode 100644 hadoop-hdds/rocks-native/src/main/native/Pipe.cpp
 delete mode 100644 hadoop-hdds/rocks-native/src/main/native/Pipe.h
 delete mode 100644 hadoop-hdds/rocks-native/src/main/native/PipeInputStream.cpp
 delete mode 100644 hadoop-hdds/rocks-native/src/main/native/SSTDumpTool.cpp
 create mode 100644 hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedRawSSTFileIterator.java
 delete mode 100644 hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedSSTDumpIterator.java
 create mode 100644 hadoop-hdds/rocks-native/src/test/resources/auditlog.properties
 create mode 100644 hadoop-hdds/rocks-native/src/test/resources/log4j.properties

diff --git a/hadoop-hdds/common/src/main/resources/ozone-default.xml b/hadoop-hdds/common/src/main/resources/ozone-default.xml
index cd3a01aabc23..e9b74177e1c9 100644
--- a/hadoop-hdds/common/src/main/resources/ozone-default.xml
+++ b/hadoop-hdds/common/src/main/resources/ozone-default.xml
@@ -4234,15 +4234,6 @@
     </description>
   </property>
 
-  <property>
-    <name>ozone.om.snapshot.sst_dumptool.pool.size</name>
-    <value>1</value>
-    <tag>OZONE, OM</tag>
-    <description>
-      Threadpool size for SST Dumptool which would be used for computing snapdiff when native library is enabled.
-    </description>
-  </property>
-
   <property>
     <name>ozone.om.snapshot.load.native.lib</name>
     <value>true</value>
@@ -4252,15 +4243,6 @@
     </description>
   </property>
 
-  <property>
-    <name>ozone.om.snapshot.sst_dumptool.buffer.size</name>
-    <value>8KB</value>
-    <tag>OZONE, OM</tag>
-    <description>
-      Buffer size for SST Dumptool Pipe which would be used for computing snapdiff when native library is enabled.
-    </description>
-  </property>
-
   <property>
     <name>ozone.om.snapshot.diff.max.allowed.keys.changed.per.job</name>
     <value>10000000</value>
diff --git a/hadoop-hdds/managed-rocksdb/src/main/java/org/apache/hadoop/hdds/utils/db/managed/JniLibNamePropertyWriter.java b/hadoop-hdds/managed-rocksdb/src/main/java/org/apache/hadoop/hdds/utils/db/managed/JniLibNamePropertyWriter.java
new file mode 100644
index 000000000000..46fbeb412a84
--- /dev/null
+++ b/hadoop-hdds/managed-rocksdb/src/main/java/org/apache/hadoop/hdds/utils/db/managed/JniLibNamePropertyWriter.java
@@ -0,0 +1,48 @@
+/*
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.utils.db.managed;
+
+import org.rocksdb.util.Environment;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+/**
+ * Class to write the rocksdb lib name to a file.
+ * This would be used to build native ozone_rocksdb_tools library.
+ */
+public final class JniLibNamePropertyWriter {
+
+  private JniLibNamePropertyWriter() {
+  }
+
+  public static void main(String[] args) {
+    String filePath = args[0];
+    try (Writer writer = new OutputStreamWriter(
+        Files.newOutputStream(Paths.get(filePath)), StandardCharsets.UTF_8)) {
+      writer.write("rocksdbLibName=" +
+          Environment.getJniLibraryFileName("rocksdb"));
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+}
diff --git a/hadoop-hdds/rocks-native/pom.xml b/hadoop-hdds/rocks-native/pom.xml
index 1b29bfcbd6af..6e92f57b6c18 100644
--- a/hadoop-hdds/rocks-native/pom.xml
+++ b/hadoop-hdds/rocks-native/pom.xml
@@ -57,13 +57,16 @@
             <artifactId>mockito-inline</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+        </dependency>
     </dependencies>
     <properties>
         <allow.junit4>false</allow.junit4>
 
         <maven.compiler.source>8</maven.compiler.source>
         <maven.compiler.target>8</maven.compiler.target>
-        <zlib.url>https://zlib.net/fossils/zlib-${zlib.version}.tar.gz</zlib.url>
     </properties>
 
     <build>
@@ -120,79 +123,80 @@
             <build>
                 <plugins>
                     <plugin>
-                        <groupId>com.googlecode.maven-download-plugin</groupId>
-                        <artifactId>download-maven-plugin</artifactId>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>exec-maven-plugin</artifactId>
                         <executions>
                             <execution>
-                                <id>rocksdb source download</id>
-                                <phase>generate-sources</phase>
+                                <id>set-property</id>
+                                <phase>initialize</phase>
                                 <goals>
-                                    <goal>wget</goal>
+                                    <goal>java</goal>
                                 </goals>
                                 <configuration>
-                                    <url>https://github.com/facebook/rocksdb/archive/refs/tags/v${rocksdb.version}.tar.gz</url>
-                                    <outputFileName>rocksdb-v${rocksdb.version}.tar.gz</outputFileName>
-                                    <outputDirectory>${project.build.directory}/rocksdb</outputDirectory>
-                                </configuration>
-                            </execution>
-                            <execution>
-                                <id>zlib source download</id>
-                                <phase>generate-sources</phase>
-                                <goals>
-                                    <goal>wget</goal>
-                                </goals>
-                                <configuration>
-                                    <url>${zlib.url}</url>
-                                    <outputFileName>zlib-${zlib.version}.tar.gz</outputFileName>
-                                    <outputDirectory>${project.build.directory}/zlib</outputDirectory>
-                                </configuration>
-                            </execution>
-                            <execution>
-                                <id>bzip2 source download</id>
-                                <phase>generate-sources</phase>
-                                <goals>
-                                    <goal>wget</goal>
-                                </goals>
-                                <configuration>
-                                    <url>https://sourceware.org/pub/bzip2/bzip2-${bzip2.version}.tar.gz</url>
-                                    <outputFileName>bzip2-v${bzip2.version}.tar.gz</outputFileName>
-                                    <outputDirectory>${project.build.directory}/bzip2</outputDirectory>
+                                    <mainClass>org.apache.hadoop.hdds.utils.db.managed.JniLibNamePropertyWriter</mainClass>
+                                    <arguments>
+                                        <argument>${project.build.directory}/propertyFile.txt</argument>
+                                    </arguments>
                                 </configuration>
                             </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>properties-maven-plugin</artifactId>
+                        <executions>
                             <execution>
-                                <id>lz4 source download</id>
-                                <phase>generate-sources</phase>
+                                <id>read-property-from-file</id>
+                                <phase>initialize</phase>
                                 <goals>
-                                    <goal>wget</goal>
+                                    <goal>read-project-properties</goal>
                                 </goals>
                                 <configuration>
-                                    <url>https://github.com/lz4/lz4/archive/refs/tags/v${lz4.version}.tar.gz</url>
-                                    <outputFileName>lz4-v${lz4.version}.tar.gz</outputFileName>
-                                    <outputDirectory>${project.build.directory}/lz4</outputDirectory>
+                                    <files>
+                                        <file>${project.build.directory}/propertyFile.txt</file>
+                                    </files>
                                 </configuration>
                             </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-dependency-plugin</artifactId>
+                        <executions>
                             <execution>
-                                <id>snappy source download</id>
-                                <phase>generate-sources</phase>
+                                <id>unpack-dependency</id>
+                                <phase>initialize</phase>
                                 <goals>
-                                    <goal>wget</goal>
+                                    <goal>unpack</goal>
                                 </goals>
                                 <configuration>
-                                    <url>https://github.com/google/snappy/archive/refs/tags/${snappy.version}.tar.gz</url>
-                                    <outputFileName>snappy-v${snappy.version}.tar.gz</outputFileName>
-                                    <outputDirectory>${project.build.directory}/snappy</outputDirectory>
+                                    <artifactItems>
+                                        <artifactItem>
+                                            <groupId>org.rocksdb</groupId>
+                                            <artifactId>rocksdbjni</artifactId>
+                                            <type>jar</type>
+                                            <overWrite>false</overWrite>
+                                            <outputDirectory>${project.build.directory}/rocksdbjni</outputDirectory>
+                                        </artifactItem>
+                                    </artifactItems>
                                 </configuration>
                             </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>com.googlecode.maven-download-plugin</groupId>
+                        <artifactId>download-maven-plugin</artifactId>
+                        <executions>
                             <execution>
-                                <id>zstd source download</id>
+                                <id>rocksdb source download</id>
                                 <phase>generate-sources</phase>
                                 <goals>
                                     <goal>wget</goal>
                                 </goals>
                                 <configuration>
-                                    <url>https://github.com/facebook/zstd/archive/refs/tags/v${zstd.version}.tar.gz</url>
-                                    <outputFileName>zstd-v${zstd.version}.tar.gz</outputFileName>
-                                    <outputDirectory>${project.build.directory}/zstd</outputDirectory>
+                                    <url>https://github.com/facebook/rocksdb/archive/refs/tags/v${rocksdb.version}.tar.gz</url>
+                                    <outputFileName>rocksdb-v${rocksdb.version}.tar.gz</outputFileName>
+                                    <outputDirectory>${project.build.directory}/rocksdb</outputDirectory>
                                 </configuration>
                             </execution>
                         </executions>
@@ -226,88 +230,6 @@
                                 <configuration>
                                     <target>
                                         <untar src="${project.build.directory}/rocksdb/rocksdb-v${rocksdb.version}.tar.gz" compression="gzip" dest="${project.build.directory}/rocksdb/" />
-                                        <untar src="${project.build.directory}/zlib/zlib-${zlib.version}.tar.gz" compression="gzip" dest="${project.build.directory}/zlib/" />
-                                        <untar src="${project.build.directory}/bzip2/bzip2-v${bzip2.version}.tar.gz" compression="gzip" dest="${project.build.directory}/bzip2/" />
-                                        <untar src="${project.build.directory}/lz4/lz4-v${lz4.version}.tar.gz" compression="gzip" dest="${project.build.directory}/lz4/" />
-                                        <untar src="${project.build.directory}/snappy/snappy-v${snappy.version}.tar.gz" compression="gzip" dest="${project.build.directory}/snappy/" />
-                                        <untar src="${project.build.directory}/zstd/zstd-v${zstd.version}.tar.gz" compression="gzip" dest="${project.build.directory}/zstd/" />
-                                    </target>
-                                </configuration>
-                                <goals>
-                                    <goal>run</goal>
-                                </goals>
-                            </execution>
-                            <execution>
-                                <id>build-zlib</id>
-                                <phase>process-sources</phase>
-                                <configuration>
-                                    <target>
-                                        <chmod file="${project.build.directory}/zlib/zlib-${zlib.version}/configure" perm="775" />
-                                        <exec executable="./configure" dir="${project.build.directory}/zlib/zlib-${zlib.version}" failonerror="true">
-                                            <arg line="--static"/>
-                                            <env key="CFLAGS" value="-fPIC"/>
-                                        </exec>
-                                        <exec executable="make" dir="${project.build.directory}/zlib/zlib-${zlib.version}" failonerror="true"/>
-                                    </target>
-                                </configuration>
-                                <goals>
-                                    <goal>run</goal>
-                                </goals>
-                            </execution>
-                            <execution>
-                                <id>build-bzip2</id>
-                                <phase>process-sources</phase>
-                                <configuration>
-                                    <target>
-                                        <exec executable="make" dir="${project.build.directory}/bzip2/bzip2-${bzip2.version}" failonerror="true">
-                                            <arg line="CFLAGS='-fPIC'"/>
-                                        </exec>
-                                    </target>
-                                </configuration>
-                                <goals>
-                                    <goal>run</goal>
-                                </goals>
-                            </execution>
-                            <execution>
-                                <id>build-lz4</id>
-                                <phase>process-sources</phase>
-                                <configuration>
-                                    <target>
-                                        <exec executable="make" dir="${project.build.directory}/lz4/lz4-${lz4.version}" failonerror="true">
-                                            <arg line="CFLAGS='-fPIC'"/>
-                                        </exec>
-                                    </target>
-                                </configuration>
-                                <goals>
-                                    <goal>run</goal>
-                                </goals>
-                            </execution>
-                            <execution>
-                                <id>build-zstd</id>
-                                <phase>process-sources</phase>
-                                <configuration>
-                                    <target>
-                                        <exec executable="make" dir="${project.build.directory}/zstd/zstd-${zstd.version}" failonerror="true">
-                                            <arg line="CFLAGS='-fPIC'"/>
-                                        </exec>
-                                    </target>
-                                </configuration>
-                                <goals>
-                                    <goal>run</goal>
-                                </goals>
-                            </execution>
-                            <execution>
-                                <id>build-snappy</id>
-                                <phase>process-sources</phase>
-                                <configuration>
-                                    <target>
-                                        <mkdir dir="${project.build.directory}/snappy/lib"/>
-                                        <exec executable="cmake" failonerror="true" dir="${project.build.directory}/snappy/lib">
-                                            <arg line="${project.build.directory}/snappy/snappy-${snappy.version}"/>
-                                            <env key="CFLAGS" value="-fPIC"/>
-                                            <env key="CXXFLAGS" value="-fPIC"/>
-                                        </exec>
-                                        <exec executable="make" dir="${project.build.directory}/snappy/lib" failonerror="true"/>
                                     </target>
                                 </configuration>
                                 <goals>
@@ -326,11 +248,10 @@
                                         </exec>
                                         <exec executable="make" dir="${project.build.directory}/rocksdb/rocksdb-${rocksdb.version}" failonerror="true">
                                             <arg line="PORTABLE=1"/>
-                      <arg line="DEBUG_LEVEL=0"/>
-                                            <arg line="EXTRA_CXXFLAGS='-fPIC -I${project.build.directory}/snappy/lib -I${project.build.directory}/snappy/snappy-${snappy.version} -I${project.build.directory}/lz4/lz4-${lz4.version}/lib -I${project.build.directory}/zstd/zstd-${zstd.version}/lib -I${project.build.directory}/zstd/zstd-${zstd.version}/lib/dictBuilder -I${project.build.directory}/bzip2/bzip2-${bzip2.version} -I${project.build.directory}/zlib/zlib-${zlib.version}'"/>
-                                            <arg line="EXTRA_LDFLAGS='-L${project.build.directory}/snappy/lib -L${project.build.directory}/lz4/lz4-${lz4.version}/lib -L${project.build.directory}/zstd/zstd-${zstd.version}/lib -L${project.build.directory}/bzip2/bzip2-${bzip2.version} -L${project.build.directory}/zlib/zlib-${zlib.version}'"/>
+                                            <arg line="DEBUG_LEVEL=0"/>
+                                            <arg line="EXTRA_CXXFLAGS='-fPIC -D_GLIBCXX_USE_CXX11_ABI=0'"/>
                                             <arg line="-j${system.numCores}"/>
-                                            <arg line="tools"/>
+                                            <arg line="tools_lib"/>
                                         </exec>
                                     </target>
                                 </configuration>
@@ -353,14 +274,11 @@
                                             <arg line="-DSST_DUMP_INCLUDE=${sstDump.include}"/>
                                             <arg line="-DCMAKE_STANDARDS=${cmake.standards}"/>
                                             <arg line="-DROCKSDB_HEADERS=${project.build.directory}/rocksdb/rocksdb-${rocksdb.version}/include"/>
-                                            <arg line="-DROCKSDB_LIB=${project.build.directory}/rocksdb/rocksdb-${rocksdb.version}"/>
-                                            <arg line="-DZLIB_LIB=${project.build.directory}/zlib/zlib-${zlib.version}"/>
-                                            <arg line="-DBZIP2_LIB=${project.build.directory}/bzip2/bzip2-${bzip2.version}"/>
-                                            <arg line="-DLZ4_LIB=${project.build.directory}/lz4/lz4-${lz4.version}/lib"/>
-                                            <arg line="-DSNAPPY_LIB=${project.build.directory}/snappy/lib"/>
-                                            <arg line="-DZSTD_LIB=${project.build.directory}/zstd/zstd-${zstd.version}/lib"/>
+                                            <arg line="-DROCKSDB_TOOLS_LIB=${project.build.directory}/rocksdb/rocksdb-${rocksdb.version}"/>
+                                            <arg line="-DROCKSDB_LIB=${project.build.directory}/rocksdbjni/${rocksdbLibName}"/>
                                         </exec>
-                                        <exec executable="make" dir="${project.build.directory}/native/rocksdb" failonerror="true"/>
+                                        <exec executable="make" dir="${project.build.directory}/native/rocksdb" failonerror="true"/><delete dir="${project.build.directory}/rocksdb/rocksdb-${rocksdb.version}"
+                            includeemptydirs="true"/>
                                     </target>
                                 </configuration>
                                 <goals>
@@ -430,8 +348,8 @@
                                 <configuration>
                                     <javahPath>${env.JAVA_HOME}/bin/javah</javahPath>
                                     <javahClassNames>
-                                        <javahClassName>org.apache.hadoop.hdds.utils.db.managed.ManagedSSTDumpTool</javahClassName>
-                                        <javahClassName>org.apache.hadoop.hdds.utils.db.managed.PipeInputStream</javahClassName>
+                                        <javahClassName>org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileReader</javahClassName>
+                                        <javahClassName>org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileIterator</javahClassName>
                                     </javahClassNames>
                                     <javahOutputDirectory>${project.build.directory}/native/javah</javahOutputDirectory>
                                 </configuration>
@@ -486,8 +404,8 @@
                                         <argument>${project.build.outputDirectory}:${project.build.directory}/dependency/*</argument>
                                         <argument>-h</argument>
                                         <argument>${project.build.directory}/native/javah</argument>
-                                        <argument>${project.basedir}/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpTool.java</argument>
-                                        <argument>${project.basedir}/src/main/java/org/apache/hadoop/hdds/utils/db/managed/PipeInputStream.java</argument>
+                                        <argument>${project.basedir}/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileReader.java</argument>
+                                        <argument>${project.basedir}/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileReaderIterator.java</argument>
                                     </arguments>
                                 </configuration>
                             </execution>
diff --git a/hadoop-hdds/rocks-native/src/CMakeLists.txt b/hadoop-hdds/rocks-native/src/CMakeLists.txt
index 051660777493..4639e2a8c927 100644
--- a/hadoop-hdds/rocks-native/src/CMakeLists.txt
+++ b/hadoop-hdds/rocks-native/src/CMakeLists.txt
@@ -21,6 +21,7 @@
 #
 
 cmake_minimum_required(VERSION 2.8)
+add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
 project(ozone_native)
@@ -36,43 +37,18 @@ endif()
 include_directories(${GENERATED_JAVAH})
 if(${SST_DUMP_INCLUDE})
     include_directories(${ROCKSDB_HEADERS})
-    set(SOURCE_FILES ${NATIVE_DIR}/SSTDumpTool.cpp ${NATIVE_DIR}/PipeInputStream.cpp ${NATIVE_DIR}/Pipe.h ${NATIVE_DIR}/Pipe.cpp ${NATIVE_DIR}/cplusplus_to_java_convert.h)
-    ADD_LIBRARY(rocksdb STATIC IMPORTED)
+    set(SOURCE_FILES ${NATIVE_DIR}/ManagedRawSSTFileReader.cpp ${NATIVE_DIR}/ManagedRawSSTFileIterator.cpp ${NATIVE_DIR}/cplusplus_to_java_convert.h)
+    ADD_LIBRARY(rocksdb SHARED IMPORTED)
     set_target_properties(
             rocksdb
             PROPERTIES
-            IMPORTED_LOCATION ${ROCKSDB_LIB}/librocksdb.a)
+            IMPORTED_LOCATION ${ROCKSDB_LIB})
     ADD_LIBRARY(rocks_tools STATIC IMPORTED)
     set_target_properties(
             rocks_tools
             PROPERTIES
-            IMPORTED_LOCATION ${ROCKSDB_LIB}/librocksdb_tools.a)
-    ADD_LIBRARY(bz2 STATIC IMPORTED)
-    set_target_properties(
-            bz2
-            PROPERTIES
-            IMPORTED_LOCATION ${BZIP2_LIB}/libbz2.a)
-    ADD_LIBRARY(zlib STATIC IMPORTED)
-    set_target_properties(
-            zlib
-            PROPERTIES
-            IMPORTED_LOCATION ${ZLIB_LIB}/libz.a)
-    ADD_LIBRARY(lz4 STATIC IMPORTED)
-    set_target_properties(
-            lz4
-            PROPERTIES
-            IMPORTED_LOCATION ${LZ4_LIB}/liblz4.a)
-    ADD_LIBRARY(snappy STATIC IMPORTED)
-    set_target_properties(
-            snappy
-            PROPERTIES
-            IMPORTED_LOCATION ${SNAPPY_LIB}/libsnappy.a)
-    ADD_LIBRARY(zstd STATIC IMPORTED)
-        set_target_properties(
-                zstd
-                PROPERTIES
-                IMPORTED_LOCATION ${ZSTD_LIB}/libzstd.a)
-    set(linked_libraries ${linked_libraries} bz2 zlib rocks_tools rocksdb lz4 snappy zstd)
+            IMPORTED_LOCATION ${ROCKSDB_TOOLS_LIB}/librocksdb_tools.a)
+    set(linked_libraries ${linked_libraries} rocks_tools rocksdb)
 endif()
 add_library(ozone_rocksdb_tools SHARED ${SOURCE_FILES})
 target_link_libraries(ozone_rocksdb_tools ${linked_libraries})
diff --git a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/NativeConstants.java b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/NativeConstants.java
index d3121144d37a..8937f0803a18 100644
--- a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/NativeConstants.java
+++ b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/NativeConstants.java
@@ -26,6 +26,5 @@ public final class NativeConstants {
   private NativeConstants() {
 
   }
-  public static final String ROCKS_TOOLS_NATIVE_LIBRARY_NAME
-          = "ozone_rocksdb_tools";
+  public static final String ROCKS_TOOLS_NATIVE_LIBRARY_NAME = "ozone_rocksdb_tools";
 }
diff --git a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileIterator.java b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileIterator.java
new file mode 100644
index 000000000000..02125951c1fe
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileIterator.java
@@ -0,0 +1,118 @@
+/*
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.utils.db.managed;
+
+import com.google.common.primitives.UnsignedLong;
+import org.apache.hadoop.hdds.StringUtils;
+import org.apache.hadoop.util.ClosableIterator;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+
+/**
+ * Iterator for SSTFileReader which would read all entries including tombstones.
+ */
+public class ManagedRawSSTFileIterator<T> implements ClosableIterator<T> {
+  // Native address of pointer to the object.
+  private final long nativeHandle;
+  private final Function<KeyValue, T> transformer;
+
+  ManagedRawSSTFileIterator(long nativeHandle, Function<KeyValue, T> transformer) {
+    this.nativeHandle = nativeHandle;
+    this.transformer = transformer;
+  }
+
+  private native boolean hasNext(long handle);
+  private native void next(long handle);
+  private native byte[] getKey(long handle);
+  private native byte[] getValue(long handle);
+  private native long getSequenceNumber(long handle);
+  private native int getType(long handle);
+
+  @Override
+  public boolean hasNext() {
+    return this.hasNext(nativeHandle);
+  }
+
+  @Override
+  public T next() {
+    if (!hasNext()) {
+      throw new NoSuchElementException();
+    }
+
+    KeyValue keyValue = new KeyValue(this.getKey(nativeHandle),
+        UnsignedLong.fromLongBits(this.getSequenceNumber(this.nativeHandle)),
+        this.getType(nativeHandle),
+        this.getValue(nativeHandle));
+    this.next(nativeHandle);
+    return this.transformer.apply(keyValue);
+  }
+
+  private native void closeInternal(long handle);
+
+  @Override
+  public void close() {
+    this.closeInternal(this.nativeHandle);
+  }
+
+  /**
+   * Class containing Parsed KeyValue Record from RawSstReader output.
+   */
+  public static final class KeyValue {
+
+    private final byte[] key;
+    private final UnsignedLong sequence;
+    private final Integer type;
+    private final byte[] value;
+
+    private KeyValue(byte[] key, UnsignedLong sequence, Integer type,
+                     byte[] value) {
+      this.key = key;
+      this.sequence = sequence;
+      this.type = type;
+      this.value = value;
+    }
+
+    public byte[] getKey() {
+      return Arrays.copyOf(key, key.length);
+    }
+
+    public UnsignedLong getSequence() {
+      return sequence;
+    }
+
+    public Integer getType() {
+      return type;
+    }
+
+    public byte[] getValue() {
+      return Arrays.copyOf(value, value.length);
+    }
+
+    @Override
+    public String toString() {
+      return "KeyValue{" +
+          "key=" + StringUtils.bytes2String(key) +
+          ", sequence=" + sequence +
+          ", type=" + type +
+          ", value=" + StringUtils.bytes2String(value) +
+          '}';
+    }
+  }
+}
diff --git a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileReader.java b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileReader.java
new file mode 100644
index 000000000000..7c8783b43948
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedRawSSTFileReader.java
@@ -0,0 +1,78 @@
+/*
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.utils.db.managed;
+
+import org.apache.hadoop.hdds.utils.NativeLibraryLoader;
+import org.apache.hadoop.hdds.utils.NativeLibraryNotLoadedException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.util.function.Function;
+
+import static org.apache.hadoop.hdds.utils.NativeConstants.ROCKS_TOOLS_NATIVE_LIBRARY_NAME;
+
+/**
+ * JNI for RocksDB RawSSTFileReader.
+ */
+public class ManagedRawSSTFileReader<T> implements Closeable {
+
+  public static boolean loadLibrary() throws NativeLibraryNotLoadedException {
+    ManagedRocksObjectUtils.loadRocksDBLibrary();
+    if (!NativeLibraryLoader.getInstance().loadLibrary(ROCKS_TOOLS_NATIVE_LIBRARY_NAME)) {
+      throw new NativeLibraryNotLoadedException(ROCKS_TOOLS_NATIVE_LIBRARY_NAME);
+    }
+    return true;
+  }
+
+  private final String fileName;
+  // Native address of pointer to the object.
+  private final long nativeHandle;
+  private static final Logger LOG = LoggerFactory.getLogger(ManagedRawSSTFileReader.class);
+
+  public ManagedRawSSTFileReader(final ManagedOptions options, final String fileName, final int readAheadSize) {
+    this.fileName = fileName;
+    this.nativeHandle = this.newRawSSTFileReader(options.getNativeHandle(), fileName, readAheadSize);
+  }
+
+  public ManagedRawSSTFileIterator<T> newIterator(
+      Function<ManagedRawSSTFileIterator.KeyValue, T> transformerFunction,
+      ManagedSlice fromSlice, ManagedSlice toSlice) {
+    long fromNativeHandle = fromSlice == null ? 0 : fromSlice.getNativeHandle();
+    long toNativeHandle = toSlice == null ? 0 : toSlice.getNativeHandle();
+    LOG.info("Iterating SST file: {} with native lib. " +
+            "LowerBound: {}, UpperBound: {}", fileName, fromSlice, toSlice);
+    return new ManagedRawSSTFileIterator<>(
+        newIterator(this.nativeHandle, fromSlice != null,
+            fromNativeHandle, toSlice != null, toNativeHandle),
+        transformerFunction);
+  }
+
+  private native long newRawSSTFileReader(long optionsHandle, String filePath, int readSize);
+
+
+  private native long newIterator(long handle, boolean hasFrom, long fromSliceHandle, boolean hasTo,
+                                  long toSliceHandle);
+
+  private native void disposeInternal(long handle);
+
+  @Override
+  public void close() {
+    disposeInternal(nativeHandle);
+  }
+}
diff --git a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpIterator.java b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpIterator.java
deleted file mode 100644
index d8844eaacbcd..000000000000
--- a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpIterator.java
+++ /dev/null
@@ -1,314 +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
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * 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.utils.db.managed;
-
-import com.google.common.collect.Maps;
-import com.google.common.primitives.UnsignedLong;
-import org.apache.hadoop.hdds.StringUtils;
-import org.apache.hadoop.util.ClosableIterator;
-import org.eclipse.jetty.io.RuntimeIOException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.UncheckedIOException;
-import java.nio.ByteBuffer;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-
-/**
- * Iterator to Parse output of RocksDBSSTDumpTool.
- */
-public abstract class ManagedSSTDumpIterator<T> implements ClosableIterator<T> {
-
-  private static final Logger LOG =
-      LoggerFactory.getLogger(ManagedSSTDumpIterator.class);
-  // Since we don't have any restriction on the key & value, we are prepending
-  // the length of the pattern in the sst dump tool output.
-  // The first token in the pattern is the key.
-  // The second tells the sequence number of the key.
-  // The third token gives the type of key in the sst file.
-  // The fourth token
-  private InputStream processOutput;
-  private Optional<KeyValue> currentKey;
-  private byte[] intBuffer;
-  private Optional<KeyValue> nextKey;
-
-  private ManagedSSTDumpTool.SSTDumpToolTask sstDumpToolTask;
-  private AtomicBoolean open;
-  private StackTraceElement[] stackTrace;
-
-  public ManagedSSTDumpIterator(ManagedSSTDumpTool sstDumpTool,
-                                String sstFilePath, ManagedOptions options)
-      throws IOException {
-    this(sstDumpTool, sstFilePath, options, null, null);
-  }
-
-  public ManagedSSTDumpIterator(ManagedSSTDumpTool sstDumpTool,
-                                String sstFilePath, ManagedOptions options,
-                                ManagedSlice lowerKeyBound,
-                                ManagedSlice upperKeyBound)
-      throws IOException {
-    File sstFile = new File(sstFilePath);
-    if (!sstFile.exists()) {
-      throw new IOException(String.format("File in path : %s doesn't exist",
-          sstFile.getAbsolutePath()));
-    }
-    if (!sstFile.isFile()) {
-      throw new IOException(String.format("Path given: %s is not a file",
-          sstFile.getAbsolutePath()));
-    }
-    init(sstDumpTool, sstFile, options, lowerKeyBound, upperKeyBound);
-    this.stackTrace = Thread.currentThread().getStackTrace();
-  }
-
-  /**
-   * Parses next occuring number in the stream.
-   *
-   * @return Optional of the integer empty if no integer exists
-   */
-  private Optional<Integer> getNextNumberInStream() throws IOException {
-    int n = processOutput.read(intBuffer, 0, 4);
-    if (n == 4) {
-      return Optional.of(ByteBuffer.wrap(intBuffer).getInt());
-    } else if (n >= 0) {
-      throw new IllegalStateException(String.format("Integer expects " +
-          "4 bytes to be read from the stream, but read only %d bytes", n));
-    }
-    return Optional.empty();
-  }
-
-  private Optional<byte[]> getNextByteArray() throws IOException {
-    Optional<Integer> size = getNextNumberInStream();
-    if (size.isPresent()) {
-      if (LOG.isDebugEnabled()) {
-        LOG.debug("Allocating byte array, size: {}", size.get());
-      }
-      byte[] b = new byte[size.get()];
-      int n = processOutput.read(b);
-      if (n >= 0 && n != size.get()) {
-        throw new IllegalStateException(String.format("Integer expects " +
-            "4 bytes to be read from the stream, but read only %d bytes", n));
-      }
-      return Optional.of(b);
-    }
-    return Optional.empty();
-  }
-
-  private Optional<UnsignedLong> getNextUnsignedLong() throws IOException {
-    long val = 0;
-    for (int i = 0; i < 8; i++) {
-      val = val << 8;
-      int nextByte = processOutput.read();
-      if (nextByte < 0) {
-        if (i == 0) {
-          return Optional.empty();
-        }
-        throw new IllegalStateException(String.format("Long expects " +
-            "8 bytes to be read from the stream, but read only %d bytes", i));
-      }
-      val += nextByte;
-    }
-    return Optional.of(UnsignedLong.fromLongBits(val));
-  }
-
-  private void init(ManagedSSTDumpTool sstDumpTool, File sstFile,
-                    ManagedOptions options, ManagedSlice lowerKeyBound,
-                    ManagedSlice upperKeyBound) {
-    Map<String, String> argMap = Maps.newHashMap();
-    argMap.put("file", sstFile.getAbsolutePath());
-    argMap.put("silent", null);
-    argMap.put("command", "scan");
-    // strings containing '\0' do not have the same value when encode UTF-8 on
-    // java which is 0. But in jni the utf-8 encoded value for '\0'
-    // becomes -64 -128. Thus the value becomes different.
-    // In order to support this, changes have been made on the rocks-tools
-    // to pass the address of the ManagedSlice and the jni can use the object
-    // of slice directly from there.
-    if (Objects.nonNull(lowerKeyBound)) {
-      argMap.put("from", String.valueOf(lowerKeyBound.getNativeHandle()));
-    }
-    if (Objects.nonNull(upperKeyBound)) {
-      argMap.put("to", String.valueOf(upperKeyBound.getNativeHandle()));
-    }
-    this.sstDumpToolTask = sstDumpTool.run(argMap, options);
-    processOutput = sstDumpToolTask.getPipedOutput();
-    intBuffer = new byte[4];
-    open = new AtomicBoolean(true);
-    currentKey = Optional.empty();
-    nextKey = Optional.empty();
-    next();
-  }
-
-  /**
-   * Throws Runtime exception in the case iterator is closed or
-   * the native Dumptool exited with non zero exit value.
-   */
-  private void checkSanityOfProcess() {
-    if (!this.open.get()) {
-      throw new RuntimeException("Iterator has been closed");
-    }
-    if (sstDumpToolTask.getFuture().isDone() &&
-        sstDumpToolTask.exitValue() != 0) {
-      throw new RuntimeException("Process Terminated with non zero " +
-          String.format("exit value %d", sstDumpToolTask.exitValue()));
-    }
-  }
-
-  /**
-   * Checks the status of the process & sees if there is another record.
-   *
-   * @return True if next exists & false otherwise
-   * Throws Runtime Exception in case of SST File read failure
-   */
-
-  @Override
-  public boolean hasNext() {
-    checkSanityOfProcess();
-    return nextKey.isPresent();
-  }
-
-  /**
-   * Transforms Key to a certain value.
-   *
-   * @param value
-   * @return transformed Value
-   */
-  protected abstract T getTransformedValue(Optional<KeyValue> value);
-
-  /**
-   * Returns the next record from SSTDumpTool.
-   *
-   * @return next Key
-   * Throws Runtime Exception incase of failure.
-   */
-  @Override
-  public T next() {
-    checkSanityOfProcess();
-    currentKey = nextKey;
-    nextKey = Optional.empty();
-    try {
-      Optional<byte[]> key = getNextByteArray();
-      if (!key.isPresent()) {
-        return getTransformedValue(currentKey);
-      }
-      UnsignedLong sequenceNumber = getNextUnsignedLong()
-          .orElseThrow(() -> new IllegalStateException(
-              String.format("Error while trying to read sequence number" +
-                  " for key %s", StringUtils.bytes2String(key.get()))));
-
-      Integer type = getNextNumberInStream()
-          .orElseThrow(() -> new IllegalStateException(
-              String.format("Error while trying to read sequence number for " +
-                      "key %s with sequence number %s",
-                  StringUtils.bytes2String(key.get()),
-                  sequenceNumber.toString())));
-      byte[] val = getNextByteArray().orElseThrow(() ->
-          new IllegalStateException(
-              String.format("Error while trying to read sequence number for " +
-                      "key %s with sequence number %s of type %d",
-                  StringUtils.bytes2String(key.get()),
-                  sequenceNumber.toString(), type)));
-      nextKey = Optional.of(new KeyValue(key.get(), sequenceNumber, type, val));
-    } catch (IOException e) {
-      // TODO [SNAPSHOT] Throw custom snapshot exception
-      throw new RuntimeIOException(e);
-    }
-    return getTransformedValue(currentKey);
-  }
-
-  @Override
-  public synchronized void close() throws UncheckedIOException {
-    if (this.sstDumpToolTask != null) {
-      if (!this.sstDumpToolTask.getFuture().isDone()) {
-        this.sstDumpToolTask.getFuture().cancel(true);
-      }
-      try {
-        this.processOutput.close();
-      } catch (IOException e) {
-        throw new UncheckedIOException(e);
-      }
-    }
-    open.compareAndSet(true, false);
-  }
-
-  @Override
-  protected void finalize() throws Throwable {
-    if (open.get()) {
-      LOG.warn("{}  is not closed properly." +
-              " StackTrace for unclosed instance: {}",
-          this.getClass().getName(),
-          Arrays.stream(stackTrace)
-              .map(StackTraceElement::toString).collect(
-                  Collectors.joining("\n")));
-    }
-    this.close();
-    super.finalize();
-  }
-
-  /**
-   * Class containing Parsed KeyValue Record from Sst Dumptool output.
-   */
-  public static final class KeyValue {
-
-    private final byte[] key;
-    private final UnsignedLong sequence;
-    private final Integer type;
-    private final byte[] value;
-
-    private KeyValue(byte[] key, UnsignedLong sequence, Integer type,
-                     byte[] value) {
-      this.key = key;
-      this.sequence = sequence;
-      this.type = type;
-      this.value = value;
-    }
-
-    public byte[] getKey() {
-      return key;
-    }
-
-    public UnsignedLong getSequence() {
-      return sequence;
-    }
-
-    public Integer getType() {
-      return type;
-    }
-
-    public byte[] getValue() {
-      return value;
-    }
-
-    @Override
-    public String toString() {
-      return "KeyValue{" +
-          "key=" + StringUtils.bytes2String(key) +
-          ", sequence=" + sequence +
-          ", type=" + type +
-          ", value=" + StringUtils.bytes2String(value) +
-          '}';
-    }
-  }
-}
diff --git a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpTool.java b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpTool.java
deleted file mode 100644
index 5d965d7398e0..000000000000
--- a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/ManagedSSTDumpTool.java
+++ /dev/null
@@ -1,99 +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.hdds.utils.db.managed;
-
-import org.apache.hadoop.hdds.utils.NativeLibraryLoader;
-import org.apache.hadoop.hdds.utils.NativeLibraryNotLoadedException;
-
-import java.io.InputStream;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-
-import static org.apache.hadoop.hdds.utils.NativeConstants.ROCKS_TOOLS_NATIVE_LIBRARY_NAME;
-
-/**
- * JNI for RocksDB SSTDumpTool. Pipes the output to an output stream
- */
-public class ManagedSSTDumpTool {
-
-  private int bufferCapacity;
-  private ExecutorService executorService;
-
-  public ManagedSSTDumpTool(ExecutorService executorService,
-                            int bufferCapacity)
-      throws NativeLibraryNotLoadedException {
-    if (!NativeLibraryLoader.getInstance()
-        .loadLibrary(ROCKS_TOOLS_NATIVE_LIBRARY_NAME)) {
-      throw new NativeLibraryNotLoadedException(
-          ROCKS_TOOLS_NATIVE_LIBRARY_NAME);
-    }
-    this.bufferCapacity = bufferCapacity;
-    this.executorService = executorService;
-  }
-
-  public SSTDumpToolTask run(String[] args, ManagedOptions options) {
-    PipeInputStream pipeInputStream = new PipeInputStream(bufferCapacity);
-    return new SSTDumpToolTask(this.executorService.submit(() ->
-        this.runInternal(args, options.getNativeHandle(),
-            pipeInputStream.getNativeHandle())), pipeInputStream);
-  }
-
-  public SSTDumpToolTask run(Map<String, String> args, ManagedOptions options) {
-    return this.run(args.entrySet().stream().map(e -> "--"
-        + (e.getValue() == null || e.getValue().isEmpty() ? e.getKey() :
-        e.getKey() + "=" + e.getValue())).toArray(String[]::new), options);
-  }
-
-  private native int runInternal(String[] args, long optionsHandle,
-                                 long pipeHandle);
-
-  /**
-   * Class holding piped output of SST Dumptool & future of command.
-   */
-  static class SSTDumpToolTask {
-    private Future<Integer> future;
-    private InputStream pipedOutput;
-
-    SSTDumpToolTask(Future<Integer> future, InputStream pipedOutput) {
-      this.future = future;
-      this.pipedOutput = pipedOutput;
-    }
-
-    public Future<Integer> getFuture() {
-      return future;
-    }
-
-    public InputStream getPipedOutput() {
-      return pipedOutput;
-    }
-
-    public int exitValue() {
-      if (this.future.isDone()) {
-        try {
-          return future.get();
-        } catch (InterruptedException | ExecutionException e) {
-          return 1;
-        }
-      }
-      return 0;
-    }
-  }
-}
diff --git a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/PipeInputStream.java b/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/PipeInputStream.java
deleted file mode 100644
index df4f613f98e2..000000000000
--- a/hadoop-hdds/rocks-native/src/main/java/org/apache/hadoop/hdds/utils/db/managed/PipeInputStream.java
+++ /dev/null
@@ -1,88 +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.hdds.utils.db.managed;
-
-import java.io.InputStream;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * JNI for reading data from pipe.
- */
-public class PipeInputStream extends InputStream {
-
-  private byte[] byteBuffer;
-  private long nativeHandle;
-  private int numberOfBytesLeftToRead;
-  private int index = 0;
-  private int capacity;
-
-  private AtomicBoolean cleanup;
-
-  PipeInputStream(int capacity) {
-    this.byteBuffer = new byte[capacity];
-    this.numberOfBytesLeftToRead = 0;
-    this.capacity = capacity;
-    this.nativeHandle = newPipe();
-    this.cleanup = new AtomicBoolean(false);
-  }
-
-  long getNativeHandle() {
-    return nativeHandle;
-  }
-
-  @Override
-  public int read() {
-    if (numberOfBytesLeftToRead < 0) {
-      this.close();
-      return -1;
-    }
-    while (numberOfBytesLeftToRead == 0) {
-      numberOfBytesLeftToRead = readInternal(byteBuffer, capacity,
-              nativeHandle);
-      index = 0;
-      if (numberOfBytesLeftToRead != 0) {
-        return read();
-      }
-    }
-    numberOfBytesLeftToRead--;
-    int ret = byteBuffer[index] & 0xFF;
-    index += 1;
-    return ret;
-  }
-
-  private native long newPipe();
-
-  private native int readInternal(byte[] buff, int numberOfBytes,
-                                  long pipeHandle);
-
-  private native void closeInternal(long pipeHandle);
-
-  @Override
-  public void close() {
-    if (this.cleanup.compareAndSet(false, true)) {
-      closeInternal(this.nativeHandle);
-    }
-  }
-
-  @Override
-  protected void finalize() throws Throwable {
-    close();
-    super.finalize();
-  }
-}
diff --git a/hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileIterator.cpp b/hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileIterator.cpp
new file mode 100644
index 000000000000..1cf222528379
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileIterator.cpp
@@ -0,0 +1,90 @@
+/*
+ * 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.
+ */
+
+#include "org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator.h"
+#include "rocksdb/options.h"
+#include "rocksdb/raw_iterator.h"
+#include <string>
+#include "cplusplus_to_java_convert.h"
+#include <iostream>
+
+jboolean Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_hasNext(JNIEnv *env, jobject obj,
+                                                                                           jlong native_handle) {
+    return static_cast<jboolean>(reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle)->Valid());
+}
+
+void Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_next(JNIEnv *env, jobject obj,
+                                                                                       jlong native_handle) {
+    reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle)->Next();
+}
+
+jbyteArray Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_getKey(JNIEnv *env,
+                                                                                               jobject obj,
+                                                                                               jlong native_handle) {
+    ROCKSDB_NAMESPACE::Slice slice = reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle)->key();
+    jbyteArray jkey = env->NewByteArray(static_cast<jsize>(slice.size()));
+    if (jkey == nullptr) {
+        // exception thrown: OutOfMemoryError
+        return nullptr;
+    }
+    env->SetByteArrayRegion(
+            jkey, 0, static_cast<jsize>(slice.size()),
+            const_cast<jbyte*>(reinterpret_cast<const jbyte*>(slice.data())));
+    return jkey;
+}
+
+
+jbyteArray Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_getValue(JNIEnv *env,
+                                                                                               jobject obj,
+                                                                                               jlong native_handle) {
+    ROCKSDB_NAMESPACE::Slice slice = reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle)->value();
+    jbyteArray jkey = env->NewByteArray(static_cast<jsize>(slice.size()));
+    if (jkey == nullptr) {
+        // exception thrown: OutOfMemoryError
+        return nullptr;
+    }
+    env->SetByteArrayRegion(
+            jkey, 0, static_cast<jsize>(slice.size()),
+            const_cast<jbyte*>(reinterpret_cast<const jbyte*>(slice.data())));
+    return jkey;
+}
+
+jlong Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_getSequenceNumber(JNIEnv *env,
+                                                                                                     jobject obj,
+                                                                                                     jlong native_handle) {
+    uint64_t sequence_number =
+            reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle)->sequenceNumber();
+    jlong result;
+    std::memcpy(&result, &sequence_number, sizeof(jlong));
+    return result;
+}
+
+
+jint Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_getType(JNIEnv *env,
+                                                                                          jobject obj,
+                                                                                          jlong native_handle) {
+    uint32_t type = reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle)->type();
+    return static_cast<jint>(type);
+}
+
+
+void Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileIterator_closeInternal(JNIEnv *env,
+                                                                                                jobject obj,
+                                                                                                jlong native_handle) {
+    delete reinterpret_cast<ROCKSDB_NAMESPACE::RawIterator*>(native_handle);
+}
diff --git a/hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileReader.cpp b/hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileReader.cpp
new file mode 100644
index 000000000000..f3b8dc02639d
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/main/native/ManagedRawSSTFileReader.cpp
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+#include "org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileReader.h"
+#include "rocksdb/options.h"
+#include "rocksdb/raw_sst_file_reader.h"
+#include "rocksdb/raw_iterator.h"
+#include <string>
+#include "cplusplus_to_java_convert.h"
+#include <iostream>
+
+jlong Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileReader_newRawSSTFileReader(JNIEnv *env, jobject obj,
+                                                                                               jlong options_handle,
+                                                                                               jstring jfilename,
+                                                                                               jint readahead_size) {
+    ROCKSDB_NAMESPACE::Options *options = reinterpret_cast<ROCKSDB_NAMESPACE::Options *>(options_handle);
+    const char *file_path = env->GetStringUTFChars(jfilename, nullptr);
+    size_t read_ahead_size_value = static_cast<size_t>(readahead_size);
+    ROCKSDB_NAMESPACE::RawSstFileReader* raw_sst_file_reader =
+            new ROCKSDB_NAMESPACE::RawSstFileReader(*options, file_path, read_ahead_size_value, true, true);
+    env->ReleaseStringUTFChars(jfilename, file_path);
+    return GET_CPLUSPLUS_POINTER(raw_sst_file_reader);
+}
+
+jlong Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileReader_newIterator(JNIEnv *env, jobject obj,
+                                                                                       jlong native_handle,
+                                                                                       jboolean jhas_from,
+                                                                                       jlong from_slice_handle,
+                                                                                       jboolean jhas_to,
+                                                                                       jlong to_slice_handle) {
+    ROCKSDB_NAMESPACE::Slice* from_slice = nullptr;
+    ROCKSDB_NAMESPACE::Slice* to_slice = nullptr;
+    ROCKSDB_NAMESPACE::RawSstFileReader* raw_sst_file_reader =
+            reinterpret_cast<ROCKSDB_NAMESPACE::RawSstFileReader*>(native_handle);
+    bool has_from = static_cast<bool>(jhas_from);
+    bool has_to = static_cast<bool>(jhas_to);
+    if (has_from) {
+        from_slice = reinterpret_cast<ROCKSDB_NAMESPACE::Slice*>(from_slice_handle);
+    }
+    if (has_to) {
+        to_slice = reinterpret_cast<ROCKSDB_NAMESPACE::Slice*>(to_slice_handle);
+    }
+    ROCKSDB_NAMESPACE::RawIterator* iterator = raw_sst_file_reader->newIterator(has_from, from_slice, has_to, to_slice);
+    return GET_CPLUSPLUS_POINTER(iterator);
+}
+
+void Java_org_apache_hadoop_hdds_utils_db_managed_ManagedRawSSTFileReader_disposeInternal(JNIEnv *env, jobject obj,
+                                                                                          jlong native_handle) {
+    delete reinterpret_cast<ROCKSDB_NAMESPACE::RawSstFileReader*>(native_handle);
+}
diff --git a/hadoop-hdds/rocks-native/src/main/native/Pipe.cpp b/hadoop-hdds/rocks-native/src/main/native/Pipe.cpp
deleted file mode 100644
index f1dd54438700..000000000000
--- a/hadoop-hdds/rocks-native/src/main/native/Pipe.cpp
+++ /dev/null
@@ -1,37 +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.
- */
-
-#include "Pipe.h"
-#include <unistd.h>
-
-const int Pipe::READ_FILE_DESCRIPTOR_IDX = 0;
-const int Pipe::WRITE_FILE_DESCRIPTOR_IDX = 1;
-
-Pipe::Pipe() {
-    pipe(p);
-    open = true;
-}
-
-Pipe::~Pipe() {
-    ::close(p[Pipe::READ_FILE_DESCRIPTOR_IDX]);
-    ::close(p[Pipe::WRITE_FILE_DESCRIPTOR_IDX]);
-}
-
-void Pipe::close() {
-    open = false;
-}
diff --git a/hadoop-hdds/rocks-native/src/main/native/Pipe.h b/hadoop-hdds/rocks-native/src/main/native/Pipe.h
deleted file mode 100644
index aa75c6311cbc..000000000000
--- a/hadoop-hdds/rocks-native/src/main/native/Pipe.h
+++ /dev/null
@@ -1,55 +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.
- */
-
-#ifndef ROCKS_NATIVE_PIPE_H
-#define ROCKS_NATIVE_PIPE_H
-
-#include <stdio.h>
-
-class Pipe {
-    public:
-        static const int READ_FILE_DESCRIPTOR_IDX;
-        static const int WRITE_FILE_DESCRIPTOR_IDX;
-        Pipe();
-        ~Pipe();
-        void close();
-        int getReadFd() {
-            return getPipeFileDescriptorIndex(READ_FILE_DESCRIPTOR_IDX);
-        }
-
-        int getWriteFd() {
-            return getPipeFileDescriptorIndex(WRITE_FILE_DESCRIPTOR_IDX);
-        }
-
-        int getPipeFileDescriptorIndex(int idx) {
-            return p[idx];
-        }
-
-        bool isOpen() {
-            return open;
-        }
-
-
-    private:
-        int p[2];
-        FILE* wr;
-        bool open;
-
-};
-
-#endif //ROCKS_NATIVE_PIPE_H
diff --git a/hadoop-hdds/rocks-native/src/main/native/PipeInputStream.cpp b/hadoop-hdds/rocks-native/src/main/native/PipeInputStream.cpp
deleted file mode 100644
index 53f60cdd65af..000000000000
--- a/hadoop-hdds/rocks-native/src/main/native/PipeInputStream.cpp
+++ /dev/null
@@ -1,48 +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.
- */
-
-#include <unistd.h>
-#include <iostream>
-#include "Pipe.h"
-#include "cplusplus_to_java_convert.h"
-#include "org_apache_hadoop_hdds_utils_db_managed_PipeInputStream.h"
-
-
-jlong Java_org_apache_hadoop_hdds_utils_db_managed_PipeInputStream_newPipe(JNIEnv *, jobject) {
-    Pipe *pipe = new Pipe();
-    return GET_CPLUSPLUS_POINTER(pipe);
-}
-
-jint Java_org_apache_hadoop_hdds_utils_db_managed_PipeInputStream_readInternal(JNIEnv *env, jobject object, jbyteArray jbyteArray, jint capacity, jlong nativeHandle) {
-    int cap_int = capacity;
-    Pipe *pipe = reinterpret_cast<Pipe *>(nativeHandle);
-    jbyte *b = (env)->GetByteArrayElements(jbyteArray, JNI_FALSE);
-    cap_int = read(pipe->getReadFd(), b, cap_int);
-    if (cap_int == 0) {
-        if (!pipe->isOpen()) {
-            cap_int = -1;
-        }
-    }
-    env->ReleaseByteArrayElements(jbyteArray, b, 0);
-    return cap_int;
-}
-
-void Java_org_apache_hadoop_hdds_utils_db_managed_PipeInputStream_closeInternal(JNIEnv *env, jobject object, jlong nativeHandle) {
-    delete reinterpret_cast<Pipe *>(nativeHandle);
-}
-
diff --git a/hadoop-hdds/rocks-native/src/main/native/SSTDumpTool.cpp b/hadoop-hdds/rocks-native/src/main/native/SSTDumpTool.cpp
deleted file mode 100644
index 285c5906c2d8..000000000000
--- a/hadoop-hdds/rocks-native/src/main/native/SSTDumpTool.cpp
+++ /dev/null
@@ -1,48 +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.
- */
-
-#include "org_apache_hadoop_hdds_utils_db_managed_ManagedSSTDumpTool.h"
-#include "rocksdb/options.h"
-#include "rocksdb/sst_dump_tool.h"
-#include <string>
-#include "cplusplus_to_java_convert.h"
-#include "Pipe.h"
-#include <iostream>
-
-jint Java_org_apache_hadoop_hdds_utils_db_managed_ManagedSSTDumpTool_runInternal(JNIEnv *env, jobject obj,
-  jobjectArray argsArray, jlong optionsHandle, jlong pipeHandle) {
-    ROCKSDB_NAMESPACE::SSTDumpTool dumpTool;
-    ROCKSDB_NAMESPACE::Options options;
-    Pipe *pipe = reinterpret_cast<Pipe *>(pipeHandle);
-    int length = env->GetArrayLength(argsArray);
-    char *args[length + 1];
-    for (int i = 0; i < length; i++) {
-        jstring str_val = (jstring)env->GetObjectArrayElement(argsArray, (jsize)i);
-        char *utf_str = (char *)env->GetStringUTFChars(str_val, JNI_FALSE);
-        args[i + 1] = utf_str;
-    }
-    FILE *wr = fdopen(pipe->getWriteFd(), "w");
-    int ret = dumpTool.Run(length + 1, args, options, wr);
-    for (int i = 1; i < length + 1; i++) {
-        jstring str_val = (jstring)env->GetObjectArrayElement(argsArray, (jsize)(i - 1));
-        env->ReleaseStringUTFChars(str_val, args[i]);
-    }
-    fclose(wr);
-    pipe->close();
-    return ret;
-}
diff --git a/hadoop-hdds/rocks-native/src/main/native/cplusplus_to_java_convert.h b/hadoop-hdds/rocks-native/src/main/native/cplusplus_to_java_convert.h
index efe9d4a5be24..4862ea12a1b9 100644
--- a/hadoop-hdds/rocks-native/src/main/native/cplusplus_to_java_convert.h
+++ b/hadoop-hdds/rocks-native/src/main/native/cplusplus_to_java_convert.h
@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
 //  This source code is licensed under both the GPLv2 (found in the
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
diff --git a/hadoop-hdds/rocks-native/src/main/patches/rocks-native.patch b/hadoop-hdds/rocks-native/src/main/patches/rocks-native.patch
index 841c2533b863..12dc74614a45 100644
--- a/hadoop-hdds/rocks-native/src/main/patches/rocks-native.patch
+++ b/hadoop-hdds/rocks-native/src/main/patches/rocks-native.patch
@@ -16,592 +16,531 @@
  * limitations under the License.
  */
 
-diff --git a/include/rocksdb/sst_dump_tool.h b/include/rocksdb/sst_dump_tool.h
-index 9261ba47d..1e62b88a3 100644
---- a/include/rocksdb/sst_dump_tool.h
-+++ b/include/rocksdb/sst_dump_tool.h
-@@ -11,7 +11,8 @@ namespace ROCKSDB_NAMESPACE {
- 
- class SSTDumpTool {
-  public:
--  int Run(int argc, char const* const* argv, Options options = Options());
-+  int Run(int argc, char const* const* argv, Options options = Options(),
-+          FILE* out = stdout, FILE* err = stderr);
- };
- 
- }  // namespace ROCKSDB_NAMESPACE
-diff --git a/table/sst_file_dumper.cc b/table/sst_file_dumper.cc
-index eefbaaeee..734a2f0dd 100644
---- a/table/sst_file_dumper.cc
-+++ b/table/sst_file_dumper.cc
-@@ -45,7 +45,7 @@ SstFileDumper::SstFileDumper(const Options& options,
-                              Temperature file_temp, size_t readahead_size,
-                              bool verify_checksum, bool output_hex,
-                              bool decode_blob_index, const EnvOptions& soptions,
--                             bool silent)
-+                             bool silent, FILE* out, FILE* err)
-     : file_name_(file_path),
-       read_num_(0),
-       file_temp_(file_temp),
-@@ -57,10 +57,13 @@ SstFileDumper::SstFileDumper(const Options& options,
-       ioptions_(options_),
-       moptions_(ColumnFamilyOptions(options_)),
-       read_options_(verify_checksum, false),
--      internal_comparator_(BytewiseComparator()) {
-+      internal_comparator_(BytewiseComparator()),
-+      out_(out),
-+      err_(err)
-+      {
-   read_options_.readahead_size = readahead_size;
-   if (!silent_) {
--    fprintf(stdout, "Process %s\n", file_path.c_str());
-+    fprintf(out_, "Process %s\n", file_path.c_str());
-   }
-   init_result_ = GetTableReader(file_name_);
- }
-@@ -253,17 +256,17 @@ Status SstFileDumper::ShowAllCompressionSizes(
-     int32_t compress_level_from, int32_t compress_level_to,
-     uint32_t max_dict_bytes, uint32_t zstd_max_train_bytes,
-     uint64_t max_dict_buffer_bytes, bool use_zstd_dict_trainer) {
--  fprintf(stdout, "Block Size: %" ROCKSDB_PRIszt "\n", block_size);
-+  fprintf(out_, "Block Size: %" ROCKSDB_PRIszt "\n", block_size);
-   for (auto& i : compression_types) {
-     if (CompressionTypeSupported(i.first)) {
--      fprintf(stdout, "Compression: %-24s\n", i.second);
-+      fprintf(out_, "Compression: %-24s\n", i.second);
-       CompressionOptions compress_opt;
-       compress_opt.max_dict_bytes = max_dict_bytes;
-       compress_opt.zstd_max_train_bytes = zstd_max_train_bytes;
-       compress_opt.max_dict_buffer_bytes = max_dict_buffer_bytes;
-       compress_opt.use_zstd_dict_trainer = use_zstd_dict_trainer;
-       for (int32_t j = compress_level_from; j <= compress_level_to; j++) {
--        fprintf(stdout, "Compression level: %d", j);
-+        fprintf(out_, "Compression level: %d", j);
-         compress_opt.level = j;
-         Status s = ShowCompressionSize(block_size, i.first, compress_opt);
-         if (!s.ok()) {
-@@ -271,7 +274,7 @@ Status SstFileDumper::ShowAllCompressionSizes(
-         }
-       }
-     } else {
--      fprintf(stdout, "Unsupported compression type: %s.\n", i.second);
-+      fprintf(err_, "Unsupported compression type: %s.\n", i.second);
-     }
-   }
-   return Status::OK();
-@@ -307,9 +310,9 @@ Status SstFileDumper::ShowCompressionSize(
-   }
- 
-   std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
--  fprintf(stdout, " Size: %10" PRIu64, file_size);
--  fprintf(stdout, " Blocks: %6" PRIu64, num_data_blocks);
--  fprintf(stdout, " Time Taken: %10s microsecs",
-+  fprintf(out_, " Size: %10" PRIu64, file_size);
-+  fprintf(out_, " Blocks: %6" PRIu64, num_data_blocks);
-+  fprintf(out_, " Time Taken: %10s microsecs",
-           std::to_string(
-               std::chrono::duration_cast<std::chrono::microseconds>(end - start)
-                   .count())
-@@ -342,11 +345,11 @@ Status SstFileDumper::ShowCompressionSize(
-                              : ((static_cast<double>(not_compressed_blocks) /
-                                  static_cast<double>(num_data_blocks)) *
-                                 100.0);
--  fprintf(stdout, " Compressed: %6" PRIu64 " (%5.1f%%)", compressed_blocks,
-+  fprintf(out_, " Compressed: %6" PRIu64 " (%5.1f%%)", compressed_blocks,
-           compressed_pcnt);
--  fprintf(stdout, " Not compressed (ratio): %6" PRIu64 " (%5.1f%%)",
-+  fprintf(out_, " Not compressed (ratio): %6" PRIu64 " (%5.1f%%)",
-           ratio_not_compressed_blocks, ratio_not_compressed_pcnt);
--  fprintf(stdout, " Not compressed (abort): %6" PRIu64 " (%5.1f%%)\n",
-+  fprintf(out_, " Not compressed (abort): %6" PRIu64 " (%5.1f%%)\n",
-           not_compressed_blocks, not_compressed_pcnt);
-   return Status::OK();
- }
-@@ -362,7 +365,7 @@ Status SstFileDumper::ReadTableProperties(uint64_t table_magic_number,
-       /* memory_allocator= */ nullptr, prefetch_buffer);
-   if (!s.ok()) {
-     if (!silent_) {
--      fprintf(stdout, "Not able to read table properties\n");
-+      fprintf(err_, "Not able to read table properties\n");
-     }
-   }
-   return s;
-@@ -410,7 +413,7 @@ Status SstFileDumper::SetTableOptionsByMagicNumber(
- 
-     options_.table_factory.reset(NewPlainTableFactory(plain_table_options));
-     if (!silent_) {
--      fprintf(stdout, "Sst file format: plain table\n");
-+      fprintf(out_, "Sst file format: plain table\n");
-     }
-   } else {
-     char error_msg_buffer[80];
-@@ -427,15 +430,56 @@ Status SstFileDumper::SetOldTableOptions() {
-   assert(table_properties_ == nullptr);
-   options_.table_factory = std::make_shared<BlockBasedTableFactory>();
-   if (!silent_) {
--    fprintf(stdout, "Sst file format: block-based(old version)\n");
-+    fprintf(out_, "Sst file format: block-based(old version)\n");
-   }
- 
-   return Status::OK();
- }
- 
-+void write(int value, FILE* file) {
-+  char b[4];
-+  b[3] =  value & 0x000000ff;
-+  b[2] = (value & 0x0000ff00) >> 8;
-+  b[1] = (value & 0x00ff0000) >> 16;
-+  b[0] = (value & 0xff000000) >> 24;
-+  std::fwrite(b, 4, 1, file);
+diff --git a/include/rocksdb/raw_iterator.h b/include/rocksdb/raw_iterator.h
+new file mode 100644
+index 000000000..21242ed15
+--- /dev/null
++++ b/include/rocksdb/raw_iterator.h
+@@ -0,0 +1,25 @@
++//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
++//  This source code is licensed under both the GPLv2 (found in the
++//  COPYING file in the root directory) and Apache 2.0 License
++//  (found in the LICENSE.Apache file in the root directory).
++#pragma once
++#ifndef ROCKSDB_LITE
++
++
++#include "rocksdb/advanced_options.h"
++namespace ROCKSDB_NAMESPACE {
++
++class RawIterator {
++ public:
++  virtual ~RawIterator() {}
++  virtual bool Valid() const = 0;
++  virtual Slice key() const = 0;
++  virtual Slice value() const = 0;
++  virtual uint64_t sequenceNumber() const = 0;
++  virtual uint32_t type() const = 0;
++  virtual void Next() = 0;
++};
++
++}  // namespace ROCKSDB_NAMESPACE
++
++#endif  // ROCKSDB_LITE
+diff --git a/include/rocksdb/raw_sst_file_reader.h b/include/rocksdb/raw_sst_file_reader.h
+new file mode 100644
+index 000000000..09e748208
+--- /dev/null
++++ b/include/rocksdb/raw_sst_file_reader.h
+@@ -0,0 +1,62 @@
++//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
++//  This source code is licensed under both the GPLv2 (found in the
++//  COPYING file in the root directory) and Apache 2.0 License
++//  (found in the LICENSE.Apache file in the root directory).
++#pragma once
++#ifndef ROCKSDB_LITE
++
++#include <memory>
++#include <string>
++
++#include "rocksdb/raw_iterator.h"
++#include "rocksdb/advanced_options.h"
++#include "rocksdb/options.h"
++
++
++
++namespace ROCKSDB_NAMESPACE {
++
++class RawSstFileReader {
++ public:
++
++  RawSstFileReader(const Options& options, const std::string& file_name,
++            size_t readahead_size, bool verify_checksum,
++            bool silent = false);
++  ~RawSstFileReader();
++
++  RawIterator* newIterator(bool has_from, Slice* from,
++                           bool has_to, Slice *to);
++  Status getStatus() { return init_result_; }
++
++ private:
++  // Get the TableReader implementation for the sst file
++  Status GetTableReader(const std::string& file_path);
++  Status ReadTableProperties(uint64_t table_magic_number,
++                             uint64_t file_size);
++
++  Status SetTableOptionsByMagicNumber(uint64_t table_magic_number);
++  Status SetOldTableOptions();
++
++  // Helper function to call the factory with settings specific to the
++  // factory implementation
++  Status NewTableReader(uint64_t file_size);
++
++  std::string file_name_;
++  Temperature file_temp_;
++
++  // less verbose in stdout/stderr
++  bool silent_;
++
++  // options_ and internal_comparator_ will also be used in
++  // ReadSequential internally (specifically, seek-related operations)
++  Options options_;
++
++  Status init_result_;
++
++  struct Rep;
++  std::unique_ptr<Rep> rep_;
++};
++
++}  // namespace ROCKSDB_NAMESPACE
++
++#endif  // ROCKSDB_LITE
+diff --git a/src.mk b/src.mk
+index b94bc43ca..c13e5cde6 100644
+--- a/src.mk
++++ b/src.mk
+@@ -338,11 +338,8 @@ RANGE_TREE_SOURCES =\
+   utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.cc
+
+ TOOL_LIB_SOURCES =                                              \
+-  tools/io_tracer_parser_tool.cc                                \
+-  tools/ldb_cmd.cc                                              \
+-  tools/ldb_tool.cc                                             \
+-  tools/sst_dump_tool.cc                                        \
+-  utilities/blob_db/blob_dump_tool.cc                           \
++  tools/raw_sst_file_reader.cc                                  \
++  tools/raw_sst_file_iterator.cc                                \
+
+ ANALYZER_LIB_SOURCES =                                          \
+   tools/block_cache_analyzer/block_cache_trace_analyzer.cc      \
+diff --git a/tools/raw_sst_file_iterator.cc b/tools/raw_sst_file_iterator.cc
+new file mode 100644
+index 000000000..3051637a3
+--- /dev/null
++++ b/tools/raw_sst_file_iterator.cc
+@@ -0,0 +1,76 @@
++//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
++//  This source code is licensed under both the GPLv2 (found in the
++//  COPYING file in the root directory) and Apache 2.0 License
++//  (found in the LICENSE.Apache file in the root directory).
++//
++#ifndef ROCKSDB_LITE
++
++
++#include <cinttypes>
++#include <memory>
++
++#include "db/memtable.h"
++#include "db/write_batch_internal.h"
++#include "rocksdb/status.h"
++#include "rocksdb/utilities/ldb_cmd.h"
++#include "table/block_based/block.h"
++#include "table/block_based/block_based_table_builder.h"
++#include "table/block_based/block_based_table_factory.h"
++#include "table/meta_blocks.h"
++#include "table/plain/plain_table_factory.h"
++#include "tools/raw_sst_file_iterator.h"
++
++namespace ROCKSDB_NAMESPACE {
++
++RawSstFileIterator::RawSstFileIterator(InternalIterator* iterator,
++                             bool has_from, Slice* from_key,
++                             bool has_to, Slice* to_key)
++    : iter_(iterator),
++      ikey(new ParsedInternalKey()),
++      has_to_(has_to),
++      to_key_(to_key) {
++  if (has_from) {
++    InternalKey k;
++    k.SetMinPossibleForUserKey(*from_key);
++    iter_->Seek(k.Encode());
++  } else {
++    iter_->SeekToFirst();
++  }
++  initKey();
++}
++
++bool RawSstFileIterator::Valid() const {
++  return iter_->Valid() && (!has_to_ ||
++                            BytewiseComparator()->Compare(
++                                key(), *to_key_) < 0);
++}
++
++void RawSstFileIterator::initKey() {
++  if (iter_->Valid()) {
++    ParseInternalKey(iter_->key(), ikey, true /* log_err_key */);
++  }
 +}
++void RawSstFileIterator::Next() {
++  iter_->Next();
++  initKey();
++
++}
++
++Slice RawSstFileIterator::key() const {
++  return ikey->user_key;
++}
++
++uint64_t RawSstFileIterator::sequenceNumber() const {
++    return ikey->sequence;
++}
++
++uint32_t RawSstFileIterator::type() const {
++    return static_cast<int>(ikey->type);
++}
++
++Slice RawSstFileIterator::value() const {
++    return iter_->value();
++}
++}  // namespace ROCKSDB_NAMESPACE
++
++#endif  // ROCKSDB_LITE
+diff --git a/tools/raw_sst_file_iterator.h b/tools/raw_sst_file_iterator.h
+new file mode 100644
+index 000000000..58e34b260
+--- /dev/null
++++ b/tools/raw_sst_file_iterator.h
+@@ -0,0 +1,45 @@
++//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
++//  This source code is licensed under both the GPLv2 (found in the
++//  COPYING file in the root directory) and Apache 2.0 License
++//  (found in the LICENSE.Apache file in the root directory).
++#pragma once
++#ifndef ROCKSDB_LITE
 +
-+void write(const char* value, int length, FILE* file) {
-+  write(length, file);
-+  fwrite(value, length, 1, file);
++#include <memory>
++#include <string>
++#include "file/writable_file_writer.h"
++#include "rocksdb/advanced_options.h"
++#include "rocksdb/raw_iterator.h"
++
++namespace ROCKSDB_NAMESPACE {
++
++class RawSstFileIterator : public RawIterator {
++ public:
++  explicit RawSstFileIterator(InternalIterator* iterator,
++                                    bool has_from,
++                                    Slice* from_key,
++                                    bool has_to,
++                                    Slice* to_key);
++
++  bool Valid() const override;
++  Slice key() const override;
++  Slice value() const override;
++  uint64_t sequenceNumber() const override;
++  uint32_t type() const override;
++  void Next() final override;
++
++  ~RawSstFileIterator(){
++    delete iter_;
++  }
++
++ private:
++  void initKey();
++  InternalIterator* iter_;
++  ParsedInternalKey* ikey;
++  bool has_to_;
++  Slice* to_key_;
++};
++
++}  // namespace ROCKSDB_NAMESPACE
++
++#endif  // ROCKSDB_LITE
+diff --git a/tools/raw_sst_file_reader.cc b/tools/raw_sst_file_reader.cc
+new file mode 100644
+index 000000000..5ba8a82ee
+--- /dev/null
++++ b/tools/raw_sst_file_reader.cc
+@@ -0,0 +1,272 @@
++//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
++//  This source code is licensed under both the GPLv2 (found in the
++//  COPYING file in the root directory) and Apache 2.0 License
++//  (found in the LICENSE.Apache file in the root directory).
++//
++#ifndef ROCKSDB_LITE
++
++#include "rocksdb/raw_sst_file_reader.h"
++
++#include <chrono>
++#include <cinttypes>
++#include <map>
++#include <memory>
++
++
++#include "db/memtable.h"
++#include "db/write_batch_internal.h"
++#include "options/cf_options.h"
++#include "rocksdb/env.h"
++#include "rocksdb/slice_transform.h"
++#include "rocksdb/status.h"
++#include "rocksdb/table_properties.h"
++#include "rocksdb/utilities/ldb_cmd.h"
++#include "table/block_based/block.h"
++#include "table/block_based/block_based_table_builder.h"
++#include "table/block_based/block_based_table_factory.h"
++#include "table/format.h"
++#include "table/meta_blocks.h"
++#include "table/plain/plain_table_factory.h"
++#include "table/table_reader.h"
++#include "tools/raw_sst_file_iterator.h"
++#include "db/dbformat.h"
++
++namespace ROCKSDB_NAMESPACE {
++
++struct RawSstFileReader::Rep {
++  Options options;
++  EnvOptions soptions_;
++  ReadOptions read_options_;
++  ImmutableOptions ioptions_;
++  MutableCFOptions moptions_;
++  InternalKeyComparator internal_comparator_;
++  std::unique_ptr<TableProperties> table_properties_;
++  std::unique_ptr<TableReader> table_reader_;
++  std::unique_ptr<RandomAccessFileReader> file_;
++
++  Rep(const Options& opts, bool verify_checksum, size_t readahead_size)
++      : options(opts),
++        soptions_(EnvOptions()),
++        read_options_(verify_checksum, false),
++        ioptions_(options),
++        moptions_(ColumnFamilyOptions(options)),
++        internal_comparator_(InternalKeyComparator(BytewiseComparator())) {
++    read_options_.readahead_size = readahead_size;
++  }
++};
++
++RawSstFileReader::RawSstFileReader(const Options& options,
++                                   const std::string& file_name,
++                                   size_t readahead_size,
++                                   bool verify_checksum,
++                                   bool silent) :rep_(new Rep(options,
++                                                               verify_checksum,
++                                                               readahead_size)) {
++  file_name_ = file_name;
++  silent_ = silent;
++  options_ = options;
++  file_temp_ = Temperature::kUnknown;
++  init_result_ = GetTableReader(file_name_);
 +}
 +
-+void write(const std::string& value, FILE* file) {
-+  write(value.data(), (int)value.length(), file);
++RawSstFileReader::~RawSstFileReader() {}
++
++
++
++extern const uint64_t kBlockBasedTableMagicNumber;
++extern const uint64_t kLegacyBlockBasedTableMagicNumber;
++extern const uint64_t kPlainTableMagicNumber;
++extern const uint64_t kLegacyPlainTableMagicNumber;
++
++Status RawSstFileReader::GetTableReader(const std::string& file_path) {
++  // Warning about 'magic_number' being uninitialized shows up only in UBsan
++  // builds. Though access is guarded by 's.ok()' checks, fix the issue to
++  // avoid any warnings.
++  uint64_t magic_number = Footer::kNullTableMagicNumber;
++
++  // read table magic number
++  Footer footer;
++
++  const auto& fs = options_.env->GetFileSystem();
++  std::unique_ptr<FSRandomAccessFile> file;
++  uint64_t file_size = 0;
++  FileOptions fopts = rep_->soptions_;
++  fopts.temperature = file_temp_;
++  Status s = fs->NewRandomAccessFile(file_path, fopts, &file, nullptr);
++  if (s.ok()) {
++    s = fs->GetFileSize(file_path, IOOptions(), &file_size, nullptr);
++  }
++
++  // check empty file
++  // if true, skip further processing of this file
++  if (file_size == 0) {
++    return Status::Aborted(file_path, "Empty file");
++  }
++
++  rep_->file_.reset(new RandomAccessFileReader(std::move(file), file_path));
++
++  FilePrefetchBuffer prefetch_buffer(
++      0 /* readahead_size */, 0 /* max_readahead_size */, true /* enable */,
++      false /* track_min_offset */);
++  if (s.ok()) {
++    const uint64_t kSstDumpTailPrefetchSize = 512 * 1024;
++    uint64_t prefetch_size = (file_size > kSstDumpTailPrefetchSize)
++                                 ? kSstDumpTailPrefetchSize
++                                 : file_size;
++    uint64_t prefetch_off = file_size - prefetch_size;
++    IOOptions opts;
++    s = prefetch_buffer.Prefetch(opts, rep_->file_.get(), prefetch_off,
++                                 static_cast<size_t>(prefetch_size),
++                                 Env::IO_TOTAL /* rate_limiter_priority */);
++
++    s = ReadFooterFromFile(opts, rep_->file_.get(), &prefetch_buffer, file_size,
++                           &footer);
++  }
++  if (s.ok()) {
++    magic_number = footer.table_magic_number();
++  }
++
++  if (s.ok()) {
++    if (magic_number == kPlainTableMagicNumber ||
++        magic_number == kLegacyPlainTableMagicNumber) {
++      rep_->soptions_.use_mmap_reads = true;
++
++      fs->NewRandomAccessFile(file_path, fopts, &file, nullptr);
++      rep_->file_.reset(new RandomAccessFileReader(std::move(file), file_path));
++    }
++
++    s = ROCKSDB_NAMESPACE::ReadTableProperties(
++        rep_->file_.get(), file_size, magic_number, rep_->ioptions_, &(rep_->table_properties_),
++        /* memory_allocator= */ nullptr, (magic_number == kBlockBasedTableMagicNumber)
++                                             ? &prefetch_buffer
++                                             : nullptr);
++    // For old sst format, ReadTableProperties might fail but file can be read
++    if (s.ok()) {
++      s = SetTableOptionsByMagicNumber(magic_number);
++      if (s.ok()) {
++        if (rep_->table_properties_ && !rep_->table_properties_->comparator_name.empty()) {
++          ConfigOptions config_options;
++          const Comparator* user_comparator = nullptr;
++          s = Comparator::CreateFromString(config_options,
++                                           rep_->table_properties_->comparator_name,
++                                           &user_comparator);
++          if (s.ok()) {
++            assert(user_comparator);
++            rep_->internal_comparator_ = InternalKeyComparator(user_comparator);
++          }
++        }
++      }
++    } else {
++      if (!silent_) {
++        fprintf(stderr, "Not able to read table properties\n");
++      }
++      s = SetOldTableOptions();
++    }
++    options_.comparator = rep_->internal_comparator_.user_comparator();
++  }
++
++  if (s.ok()) {
++    s = NewTableReader(file_size);
++  }
++  return s;
 +}
 +
-+void write(Slice &slice, FILE* file) {
-+  int size = (int)slice.size();
-+  write(slice.data(), size, file);
++Status RawSstFileReader::NewTableReader(uint64_t file_size) {
++  auto t_opt =
++      TableReaderOptions(rep_->ioptions_, rep_->moptions_.prefix_extractor, rep_->soptions_,
++                         rep_->internal_comparator_, false /* skip_filters */,
++                         false /* imortal */, true /* force_direct_prefetch */);
++  // Allow open file with global sequence number for backward compatibility.
++  t_opt.largest_seqno = kMaxSequenceNumber;
++
++  // We need to turn off pre-fetching of index and filter nodes for
++  // BlockBasedTable
++  if (options_.table_factory->IsInstanceOf(
++          TableFactory::kBlockBasedTableName())) {
++    return options_.table_factory->NewTableReader(t_opt, std::move(rep_->file_),
++                                                  file_size, &(rep_->table_reader_),
++                                                  /*enable_prefetch=*/false);
++  }
++
++  // For all other factory implementation
++  return options_.table_factory->NewTableReader(t_opt, std::move(rep_->file_),
++                                                file_size, &(rep_->table_reader_));
 +}
 +
-+void write(SequenceNumber sequenceNumber, FILE* file) {
++Status RawSstFileReader::SetTableOptionsByMagicNumber(
++    uint64_t table_magic_number) {
++  assert(rep_->table_properties_);
++  if (table_magic_number == kBlockBasedTableMagicNumber ||
++      table_magic_number == kLegacyBlockBasedTableMagicNumber) {
++    BlockBasedTableFactory* bbtf = new BlockBasedTableFactory();
++    // To force tail prefetching, we fake reporting two useful reads of 512KB
++    // from the tail.
++    // It needs at least two data points to warm up the stats.
++    bbtf->tail_prefetch_stats()->RecordEffectiveSize(512 * 1024);
++    bbtf->tail_prefetch_stats()->RecordEffectiveSize(512 * 1024);
++
++    options_.table_factory.reset(bbtf);
++    if (!silent_) {
++      fprintf(stdout, "Sst file format: block-based\n");
++    }
++
++    auto& props = rep_->table_properties_->user_collected_properties;
++    auto pos = props.find(BlockBasedTablePropertyNames::kIndexType);
++    if (pos != props.end()) {
++      auto index_type_on_file = static_cast<BlockBasedTableOptions::IndexType>(
++          DecodeFixed32(pos->second.c_str()));
++      if (index_type_on_file ==
++          BlockBasedTableOptions::IndexType::kHashSearch) {
++        options_.prefix_extractor.reset(NewNoopTransform());
++      }
++    }
++  } else if (table_magic_number == kPlainTableMagicNumber ||
++             table_magic_number == kLegacyPlainTableMagicNumber) {
++    options_.allow_mmap_reads = true;
 +
-+  char b[8];
-+  int idx = 7;
-+  while (idx >= 0) {
-+    b[idx] = sequenceNumber % 256;
-+    sequenceNumber /= 256;
-+    idx -= 1;
++    PlainTableOptions plain_table_options;
++    plain_table_options.user_key_len = kPlainTableVariableLength;
++    plain_table_options.bloom_bits_per_key = 0;
++    plain_table_options.hash_table_ratio = 0;
++    plain_table_options.index_sparseness = 1;
++    plain_table_options.huge_page_tlb_size = 0;
++    plain_table_options.encoding_type = kPlain;
++    plain_table_options.full_scan_mode = true;
++
++    options_.table_factory.reset(NewPlainTableFactory(plain_table_options));
++    if (!silent_) {
++      fprintf(stdout, "Sst file format: plain table\n");
++    }
++  } else {
++    char error_msg_buffer[80];
++    snprintf(error_msg_buffer, sizeof(error_msg_buffer) - 1,
++             "Unsupported table magic number --- %lx",
++             (long)table_magic_number);
++    return Status::InvalidArgument(error_msg_buffer);
 +  }
-+  fwrite(b, 8, 1, file);
++
++  return Status::OK();
 +}
 +
-+void write(ParsedInternalKey &key, FILE* file) {
-+  write(key.user_key, file);
-+  write(key.sequence, file);
-+  write(static_cast<int>(key.type), file);
++Status RawSstFileReader::SetOldTableOptions() {
++  assert(rep_->table_properties_ == nullptr);
++  options_.table_factory = std::make_shared<BlockBasedTableFactory>();
++  if (!silent_) {
++    fprintf(stdout, "Sst file format: block-based(old version)\n");
++  }
++
++  return Status::OK();
 +}
 +
- Status SstFileDumper::ReadSequential(bool print_kv, uint64_t read_num,
--                                     bool has_from, const std::string& from_key,
--                                     bool has_to, const std::string& to_key,
-+                                     bool has_from, const Slice& from_key,
-+                                     bool has_to, const Slice& to_key,
-                                      bool use_from_as_prefix) {
-   if (!table_reader_) {
-     return init_result_;
-@@ -446,6 +490,7 @@ Status SstFileDumper::ReadSequential(bool print_kv, uint64_t read_num,
-       /*arena=*/nullptr, /*skip_filters=*/false,
-       TableReaderCaller::kSSTDumpTool);
-   uint64_t i = 0;
-+
-   if (has_from) {
-     InternalKey ikey;
-     ikey.SetMinPossibleForUserKey(from_key);
-@@ -453,6 +498,7 @@ Status SstFileDumper::ReadSequential(bool print_kv, uint64_t read_num,
-   } else {
-     iter->SeekToFirst();
-   }
-+
-   for (; iter->Valid(); iter->Next()) {
-     Slice key = iter->key();
-     Slice value = iter->value();
-@@ -478,22 +524,19 @@ Status SstFileDumper::ReadSequential(bool print_kv, uint64_t read_num,
- 
-     if (print_kv) {
-       if (!decode_blob_index_ || ikey.type != kTypeBlobIndex) {
--        fprintf(stdout, "%s => %s\n",
--                ikey.DebugString(true, output_hex_).c_str(),
--                value.ToString(output_hex_).c_str());
-+        write(ikey, out_);
-+        write(value, out_);
-       } else {
-         BlobIndex blob_index;
--
-         const Status s = blob_index.DecodeFrom(value);
-         if (!s.ok()) {
--          fprintf(stderr, "%s => error decoding blob index\n",
--                  ikey.DebugString(true, output_hex_).c_str());
-+          write(ikey, err_);
-+          write("error decoding blob index", err_);
-           continue;
-         }
--
--        fprintf(stdout, "%s => %s\n",
--                ikey.DebugString(true, output_hex_).c_str(),
--                blob_index.DebugString(output_hex_).c_str());
-+        write(ikey, out_);
-+        std::string v = blob_index.DebugString(output_hex_);
-+        write(v, out_);
-       }
-     }
-   }
-diff --git a/table/sst_file_dumper.h b/table/sst_file_dumper.h
-index 7be876390..768c5b1e2 100644
---- a/table/sst_file_dumper.h
-+++ b/table/sst_file_dumper.h
-@@ -22,11 +22,13 @@ class SstFileDumper {
-                          bool verify_checksum, bool output_hex,
-                          bool decode_blob_index,
-                          const EnvOptions& soptions = EnvOptions(),
--                         bool silent = false);
-+                         bool silent = false,
-+                         FILE* out = stdout,
-+                         FILE* err = stderr);
- 
-   Status ReadSequential(bool print_kv, uint64_t read_num, bool has_from,
--                        const std::string& from_key, bool has_to,
--                        const std::string& to_key,
-+                        const Slice& from_key, bool has_to,
-+                        const Slice& to_key,
-                         bool use_from_as_prefix = false);
- 
-   Status ReadTableProperties(
-@@ -94,6 +96,8 @@ class SstFileDumper {
-   ReadOptions read_options_;
-   InternalKeyComparator internal_comparator_;
-   std::unique_ptr<TableProperties> table_properties_;
-+  FILE* out_;
-+  FILE* err_;
- };
- 
- }  // namespace ROCKSDB_NAMESPACE
-diff --git a/tools/sst_dump_tool.cc b/tools/sst_dump_tool.cc
-index 7053366e7..8f248ddf3 100644
---- a/tools/sst_dump_tool.cc
-+++ b/tools/sst_dump_tool.cc
-@@ -31,7 +31,7 @@ static const std::vector<std::pair<CompressionType, const char*>>
- 
- namespace {
- 
--void print_help(bool to_stderr) {
-+void print_help(bool to_stderr, FILE* err_, FILE* out_) {
-   std::string supported_compressions;
-   for (CompressionType ct : GetSupportedCompressions()) {
-     if (!supported_compressions.empty()) {
-@@ -43,7 +43,7 @@ void print_help(bool to_stderr) {
-     supported_compressions += str;
-   }
-   fprintf(
--      to_stderr ? stderr : stdout,
-+      to_stderr ? err_ : out_,
-       R"(sst_dump --file=<data_dir_OR_sst_file> [--command=check|scan|raw|recompress|identify]
-     --file=<data_dir_OR_sst_file>
-       Path to SST file or directory containing SST files
-@@ -149,7 +149,13 @@ bool ParseIntArg(const char* arg, const std::string arg_name,
- }
- }  // namespace
- 
--int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-+Slice* AssignSlicePrependedWithLength(const char* buf) {
-+  long val = std::stol(buf);
-+  return reinterpret_cast<Slice *>(val);
++RawIterator* RawSstFileReader::newIterator(
++    bool has_from, Slice* from, bool has_to, Slice* to) {
++  InternalIterator* iter = rep_->table_reader_->NewIterator(
++      rep_->read_options_, rep_->moptions_.prefix_extractor.get(),
++      /*arena=*/nullptr, /*skip_filters=*/false,
++      TableReaderCaller::kSSTDumpTool);
++  return new RawSstFileIterator(iter, has_from, from, has_to, to);
++
 +}
++}  // namespace ROCKSDB_NAMESPACE
 +
-+int SSTDumpTool::Run(int argc, char const* const* argv, Options options,
-+                     FILE* out, FILE* err) {
-   std::string env_uri, fs_uri;
-   const char* dir_or_file = nullptr;
-   uint64_t read_num = std::numeric_limits<uint64_t>::max();
-@@ -170,8 +176,9 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-   bool has_compression_level_from = false;
-   bool has_compression_level_to = false;
-   bool has_specified_compression_types = false;
--  std::string from_key;
--  std::string to_key;
-+  bool silent = false;
-+  Slice* from_key = nullptr;
-+  Slice* to_key = nullptr;
-   std::string block_size_str;
-   std::string compression_level_from_str;
-   std::string compression_level_to_str;
-@@ -197,7 +204,9 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-   int64_t tmp_val;
- 
-   for (int i = 1; i < argc; i++) {
--    if (strncmp(argv[i], "--env_uri=", 10) == 0) {
-+    if (strncmp(argv[i], "--silent", 8) == 0) {
-+      silent = true;
-+    } else if (strncmp(argv[i], "--env_uri=", 10) == 0) {
-       env_uri = argv[i] + 10;
-     } else if (strncmp(argv[i], "--fs_uri=", 9) == 0) {
-       fs_uri = argv[i] + 9;
-@@ -217,13 +226,13 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-     } else if (strncmp(argv[i], "--command=", 10) == 0) {
-       command = argv[i] + 10;
-     } else if (strncmp(argv[i], "--from=", 7) == 0) {
--      from_key = argv[i] + 7;
-+      from_key = AssignSlicePrependedWithLength(argv[i] + 7);
-       has_from = true;
-     } else if (strncmp(argv[i], "--to=", 5) == 0) {
--      to_key = argv[i] + 5;
-+      to_key = AssignSlicePrependedWithLength(argv[i] + 5);
-       has_to = true;
-     } else if (strncmp(argv[i], "--prefix=", 9) == 0) {
--      from_key = argv[i] + 9;
-+      from_key = AssignSlicePrependedWithLength( argv[i] + 9);
-       use_from_as_prefix = true;
-     } else if (strcmp(argv[i], "--show_properties") == 0) {
-       show_properties = true;
-@@ -273,7 +282,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-         std::cerr << pik_status.getState() << "\n";
-         retc = -1;
-       }
--      fprintf(stdout, "key=%s\n", ikey.DebugString(true, true).c_str());
-+      fprintf(out, "key=%s\n", ikey.DebugString(true, true).c_str());
-       return retc;
-     } else if (ParseIntArg(argv[i], "--compression_level_from=",
-                            "compression_level_from must be numeric",
-@@ -288,9 +297,9 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-                            "compression_max_dict_bytes must be numeric",
-                            &tmp_val)) {
-       if (tmp_val < 0 || tmp_val > std::numeric_limits<uint32_t>::max()) {
--        fprintf(stderr, "compression_max_dict_bytes must be a uint32_t: '%s'\n",
-+        fprintf(err, "compression_max_dict_bytes must be a uint32_t: '%s'\n",
-                 argv[i]);
--        print_help(/*to_stderr*/ true);
-+        print_help(/*to_stderr*/ true, err, out);
-         return 1;
-       }
-       compression_max_dict_bytes = static_cast<uint32_t>(tmp_val);
-@@ -298,10 +307,10 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-                            "compression_zstd_max_train_bytes must be numeric",
-                            &tmp_val)) {
-       if (tmp_val < 0 || tmp_val > std::numeric_limits<uint32_t>::max()) {
--        fprintf(stderr,
-+        fprintf(err,
-                 "compression_zstd_max_train_bytes must be a uint32_t: '%s'\n",
-                 argv[i]);
--        print_help(/*to_stderr*/ true);
-+        print_help(/*to_stderr*/ true, err, out);
-         return 1;
-       }
-       compression_zstd_max_train_bytes = static_cast<uint32_t>(tmp_val);
-@@ -309,56 +318,56 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-                            "compression_max_dict_buffer_bytes must be numeric",
-                            &tmp_val)) {
-       if (tmp_val < 0) {
--        fprintf(stderr,
-+        fprintf(err,
-                 "compression_max_dict_buffer_bytes must be positive: '%s'\n",
-                 argv[i]);
--        print_help(/*to_stderr*/ true);
-+        print_help(/*to_stderr*/ true, err, out);
-         return 1;
-       }
-       compression_max_dict_buffer_bytes = static_cast<uint64_t>(tmp_val);
-     } else if (strcmp(argv[i], "--compression_use_zstd_finalize_dict") == 0) {
-       compression_use_zstd_finalize_dict = true;
-     } else if (strcmp(argv[i], "--help") == 0) {
--      print_help(/*to_stderr*/ false);
-+      print_help(/*to_stderr*/ false, err, out);
-       return 0;
-     } else if (strcmp(argv[i], "--version") == 0) {
-       printf("%s\n", GetRocksBuildInfoAsString("sst_dump").c_str());
-       return 0;
-     } else {
--      fprintf(stderr, "Unrecognized argument '%s'\n\n", argv[i]);
--      print_help(/*to_stderr*/ true);
-+      fprintf(err, "Unrecognized argument '%s'\n\n", argv[i]);
-+      print_help(/*to_stderr*/ true, err, out);
-       return 1;
-     }
-   }
- 
-   if(has_compression_level_from && has_compression_level_to) {
-     if(!has_specified_compression_types || compression_types.size() != 1) {
--      fprintf(stderr, "Specify one compression type.\n\n");
-+      fprintf(err, "Specify one compression type.\n\n");
-       exit(1);
-     }
-   } else if(has_compression_level_from || has_compression_level_to) {
--    fprintf(stderr, "Specify both --compression_level_from and "
-+    fprintf(err, "Specify both --compression_level_from and "
-                      "--compression_level_to.\n\n");
-     exit(1);
-   }
- 
-   if (use_from_as_prefix && has_from) {
--    fprintf(stderr, "Cannot specify --prefix and --from\n\n");
-+    fprintf(err, "Cannot specify --prefix and --from\n\n");
-     exit(1);
-   }
- 
-   if (input_key_hex) {
-     if (has_from || use_from_as_prefix) {
--      from_key = ROCKSDB_NAMESPACE::LDBCommand::HexToString(from_key);
-+      *from_key = ROCKSDB_NAMESPACE::LDBCommand::HexToString(from_key -> ToString());
-     }
-     if (has_to) {
--      to_key = ROCKSDB_NAMESPACE::LDBCommand::HexToString(to_key);
-+      *to_key = ROCKSDB_NAMESPACE::LDBCommand::HexToString(to_key->ToString());
-     }
-   }
- 
-   if (dir_or_file == nullptr) {
--    fprintf(stderr, "file or directory must be specified.\n\n");
--    print_help(/*to_stderr*/ true);
-+    fprintf(err, "file or directory must be specified.\n\n");
-+    print_help(/*to_stderr*/ true, err, out);
-     exit(1);
-   }
- 
-@@ -373,10 +382,10 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-     Status s = Env::CreateFromUri(config_options, env_uri, fs_uri, &options.env,
-                                   &env_guard);
-     if (!s.ok()) {
--      fprintf(stderr, "CreateEnvFromUri: %s\n", s.ToString().c_str());
-+      fprintf(err, "CreateEnvFromUri: %s\n", s.ToString().c_str());
-       exit(1);
--    } else {
--      fprintf(stdout, "options.env is %p\n", options.env);
-+    } else if (!silent){
-+      fprintf(out, "options.env is %p\n", options.env);
-     }
-   }
- 
-@@ -390,7 +399,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-     Status s = env->FileExists(dir_or_file);
-     // dir_or_file does not exist
-     if (!s.ok()) {
--      fprintf(stderr, "%s%s: No such file or directory\n", s.ToString().c_str(),
-+      fprintf(err, "%s%s: No such file or directory\n", s.ToString().c_str(),
-               dir_or_file);
-       return 1;
-     }
-@@ -421,10 +430,11 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
- 
-     ROCKSDB_NAMESPACE::SstFileDumper dumper(
-         options, filename, Temperature::kUnknown, readahead_size,
--        verify_checksum, output_hex, decode_blob_index);
-+        verify_checksum, output_hex, decode_blob_index, EnvOptions(),
-+        silent, out, err);
-     // Not a valid SST
-     if (!dumper.getStatus().ok()) {
--      fprintf(stderr, "%s: %s\n", filename.c_str(),
-+      fprintf(err, "%s: %s\n", filename.c_str(),
-               dumper.getStatus().ToString().c_str());
-       continue;
-     } else {
-@@ -433,10 +443,11 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-       // where there is at least one valid SST
-       if (valid_sst_files.size() == 1) {
-         // from_key and to_key are only used for "check", "scan", or ""
--        if (command == "check" || command == "scan" || command == "") {
--          fprintf(stdout, "from [%s] to [%s]\n",
--                  ROCKSDB_NAMESPACE::Slice(from_key).ToString(true).c_str(),
--                  ROCKSDB_NAMESPACE::Slice(to_key).ToString(true).c_str());
-+        if (!silent && (command == "check" || command == "scan" ||
-+                        command == "")) {
-+          fprintf(out, "from [%s] to [%s]\n",
-+                  from_key->ToString(true).c_str(),
-+                  to_key->ToString(true).c_str());
-         }
-       }
-     }
-@@ -449,7 +460,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-           compression_zstd_max_train_bytes, compression_max_dict_buffer_bytes,
-           !compression_use_zstd_finalize_dict);
-       if (!st.ok()) {
--        fprintf(stderr, "Failed to recompress: %s\n", st.ToString().c_str());
-+        fprintf(err, "Failed to recompress: %s\n", st.ToString().c_str());
-         exit(1);
-       }
-       return 0;
-@@ -461,10 +472,10 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
- 
-       st = dumper.DumpTable(out_filename);
-       if (!st.ok()) {
--        fprintf(stderr, "%s: %s\n", filename.c_str(), st.ToString().c_str());
-+        fprintf(err, "%s: %s\n", filename.c_str(), st.ToString().c_str());
-         exit(1);
-       } else {
--        fprintf(stdout, "raw dump written to file %s\n", &out_filename[0]);
-+        fprintf(out, "raw dump written to file %s\n", &out_filename[0]);
-       }
-       continue;
-     }
-@@ -473,10 +484,10 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-     if (command == "" || command == "scan" || command == "check") {
-       st = dumper.ReadSequential(
-           command == "scan", read_num > 0 ? (read_num - total_read) : read_num,
--          has_from || use_from_as_prefix, from_key, has_to, to_key,
-+          has_from || use_from_as_prefix, *from_key, has_to, *to_key,
-           use_from_as_prefix);
-       if (!st.ok()) {
--        fprintf(stderr, "%s: %s\n", filename.c_str(),
-+        fprintf(err, "%s: %s\n", filename.c_str(),
-             st.ToString().c_str());
-       }
-       total_read += dumper.GetReadNumber();
-@@ -488,10 +499,10 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-     if (command == "verify") {
-       st = dumper.VerifyChecksum();
-       if (!st.ok()) {
--        fprintf(stderr, "%s is corrupted: %s\n", filename.c_str(),
-+        fprintf(err, "%s is corrupted: %s\n", filename.c_str(),
-                 st.ToString().c_str());
-       } else {
--        fprintf(stdout, "The file is ok\n");
-+        fprintf(out, "The file is ok\n");
-       }
-       continue;
-     }
-@@ -503,15 +514,15 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-           table_properties_from_reader;
-       st = dumper.ReadTableProperties(&table_properties_from_reader);
-       if (!st.ok()) {
--        fprintf(stderr, "%s: %s\n", filename.c_str(), st.ToString().c_str());
--        fprintf(stderr, "Try to use initial table properties\n");
-+        fprintf(err, "%s: %s\n", filename.c_str(), st.ToString().c_str());
-+        fprintf(err, "Try to use initial table properties\n");
-         table_properties = dumper.GetInitTableProperties();
-       } else {
-         table_properties = table_properties_from_reader.get();
-       }
-       if (table_properties != nullptr) {
-         if (show_properties) {
--          fprintf(stdout,
-+          fprintf(out,
-                   "Table Properties:\n"
-                   "------------------------------\n"
-                   "  %s",
-@@ -523,18 +534,18 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-         total_index_block_size += table_properties->index_size;
-         total_filter_block_size += table_properties->filter_size;
-         if (show_properties) {
--          fprintf(stdout,
-+          fprintf(out,
-                   "Raw user collected properties\n"
-                   "------------------------------\n");
-           for (const auto& kv : table_properties->user_collected_properties) {
-             std::string prop_name = kv.first;
-             std::string prop_val = Slice(kv.second).ToString(true);
--            fprintf(stdout, "  # %s: 0x%s\n", prop_name.c_str(),
-+            fprintf(out, "  # %s: 0x%s\n", prop_name.c_str(),
-                     prop_val.c_str());
-           }
-         }
-       } else {
--        fprintf(stderr, "Reader unexpectedly returned null properties\n");
-+        fprintf(err, "Reader unexpectedly returned null properties\n");
-       }
-     }
-   }
-@@ -555,9 +566,9 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
-     // Exit with an error state
-     if (dir) {
-       fprintf(stdout, "------------------------------\n");
--      fprintf(stderr, "No valid SST files found in %s\n", dir_or_file);
-+      fprintf(err, "No valid SST files found in %s\n", dir_or_file);
-     } else {
--      fprintf(stderr, "%s is not a valid SST file\n", dir_or_file);
-+      fprintf(err, "%s is not a valid SST file\n", dir_or_file);
-     }
-     return 1;
-   } else {
++#endif  // ROCKSDB_LITE
diff --git a/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/TestNativeLibraryLoader.java b/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/TestNativeLibraryLoader.java
index 472954f2bd57..0b0943079c6b 100644
--- a/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/TestNativeLibraryLoader.java
+++ b/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/TestNativeLibraryLoader.java
@@ -17,11 +17,12 @@
  */
 package org.apache.hadoop.hdds.utils;
 
-
+import org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileReader;
 import org.apache.ozone.test.tag.Native;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Matchers;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
@@ -34,8 +35,7 @@
 
 import static org.apache.hadoop.hdds.utils.NativeConstants.ROCKS_TOOLS_NATIVE_LIBRARY_NAME;
 import static org.apache.hadoop.hdds.utils.NativeLibraryLoader.NATIVE_LIB_TMP_DIR;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.same;
 
 /**
  * Test class for NativeLibraryLoader.
@@ -51,37 +51,27 @@ private static Stream<String> nativeLibraryDirectoryLocations()
   @Native(ROCKS_TOOLS_NATIVE_LIBRARY_NAME)
   @ParameterizedTest
   @MethodSource("nativeLibraryDirectoryLocations")
-  public void testNativeLibraryLoader(
-      String nativeLibraryDirectoryLocation) {
+  public void testNativeLibraryLoader(String nativeLibraryDirectoryLocation) throws NativeLibraryNotLoadedException {
     Map<String, Boolean> libraryLoadedMap = new HashMap<>();
     NativeLibraryLoader loader = new NativeLibraryLoader(libraryLoadedMap);
-    try (MockedStatic<NativeLibraryLoader> mockedNativeLibraryLoader =
-             Mockito.mockStatic(NativeLibraryLoader.class,
-                 Mockito.CALLS_REAL_METHODS)) {
-      mockedNativeLibraryLoader.when(() ->
-              NativeLibraryLoader.getSystemProperty(same(NATIVE_LIB_TMP_DIR)))
+    try (MockedStatic<NativeLibraryLoader> mockedNativeLibraryLoader = Mockito.mockStatic(NativeLibraryLoader.class,
+        Mockito.CALLS_REAL_METHODS)) {
+      mockedNativeLibraryLoader.when(() -> NativeLibraryLoader.getSystemProperty(same(NATIVE_LIB_TMP_DIR)))
           .thenReturn(nativeLibraryDirectoryLocation);
-      mockedNativeLibraryLoader.when(() -> NativeLibraryLoader.getInstance())
-          .thenReturn(loader);
-      Assertions.assertTrue(NativeLibraryLoader.getInstance()
-          .loadLibrary(ROCKS_TOOLS_NATIVE_LIBRARY_NAME));
-      Assertions.assertTrue(NativeLibraryLoader
-          .isLibraryLoaded(ROCKS_TOOLS_NATIVE_LIBRARY_NAME));
+      mockedNativeLibraryLoader.when(() -> NativeLibraryLoader.getInstance()).thenReturn(loader);
+      ManagedRawSSTFileReader.loadLibrary();
+      Assertions.assertTrue(NativeLibraryLoader.isLibraryLoaded(ROCKS_TOOLS_NATIVE_LIBRARY_NAME));
       // Mocking to force copy random bytes to create a lib file to
       // nativeLibraryDirectoryLocation. But load library will fail.
-      mockedNativeLibraryLoader.when(() ->
-          NativeLibraryLoader.getResourceStream(anyString()))
+      mockedNativeLibraryLoader.when(() -> NativeLibraryLoader.getResourceStream(Matchers.anyString()))
           .thenReturn(new ByteArrayInputStream(new byte[]{0, 1, 2, 3}));
       String dummyLibraryName = "dummy_lib";
       NativeLibraryLoader.getInstance().loadLibrary(dummyLibraryName);
       NativeLibraryLoader.isLibraryLoaded(dummyLibraryName);
       // Checking if the resource with random was copied to a temp file.
-      File[] libPath =
-          new File(nativeLibraryDirectoryLocation == null ? "" :
-              nativeLibraryDirectoryLocation)
-          .getAbsoluteFile().listFiles((dir, name) ->
-              name.startsWith(dummyLibraryName) &&
-                  name.endsWith(NativeLibraryLoader.getLibOsSuffix()));
+      File[] libPath = new File(nativeLibraryDirectoryLocation == null ? "" : nativeLibraryDirectoryLocation)
+          .getAbsoluteFile().listFiles((dir, name) -> name.startsWith(dummyLibraryName) &&
+              name.endsWith(NativeLibraryLoader.getLibOsSuffix()));
       Assertions.assertNotNull(libPath);
       Assertions.assertEquals(1, libPath.length);
       Assertions.assertTrue(libPath[0].delete());
diff --git a/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedRawSSTFileIterator.java b/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedRawSSTFileIterator.java
new file mode 100644
index 000000000000..00816e60d7f2
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedRawSSTFileIterator.java
@@ -0,0 +1,143 @@
+/*
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.utils.db.managed;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.hadoop.hdds.StringUtils;
+import org.apache.hadoop.hdds.utils.NativeLibraryNotLoadedException;
+import org.apache.hadoop.hdds.utils.TestUtils;
+import org.apache.ozone.test.tag.Native;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.TreeMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static org.apache.hadoop.hdds.utils.NativeConstants.ROCKS_TOOLS_NATIVE_LIBRARY_NAME;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test for ManagedRawSSTFileReaderIterator.
+ */
+@Native(ROCKS_TOOLS_NATIVE_LIBRARY_NAME)
+class TestManagedRawSSTFileIterator {
+
+  @TempDir
+  private Path tempDir;
+
+  private File createSSTFileWithKeys(
+      TreeMap<Pair<String, Integer>, String> keys) throws Exception {
+    File file = Files.createFile(tempDir.resolve("tmp_sst_file.sst")).toFile();
+    try (ManagedEnvOptions envOptions = new ManagedEnvOptions();
+         ManagedOptions managedOptions = new ManagedOptions();
+         ManagedSstFileWriter sstFileWriter = new ManagedSstFileWriter(envOptions, managedOptions)) {
+      sstFileWriter.open(file.getAbsolutePath());
+      for (Map.Entry<Pair<String, Integer>, String> entry : keys.entrySet()) {
+        if (entry.getKey().getValue() == 0) {
+          sstFileWriter.delete(entry.getKey().getKey().getBytes(StandardCharsets.UTF_8));
+        } else {
+          sstFileWriter.put(entry.getKey().getKey().getBytes(StandardCharsets.UTF_8),
+              entry.getValue().getBytes(StandardCharsets.UTF_8));
+        }
+      }
+      sstFileWriter.finish();
+    }
+    return file;
+  }
+
+  private static Stream<? extends Arguments> keyValueFormatArgs() {
+    return Stream.of(Arguments.of(Named.of("Key starting with a single quote", "'key%1$d=>"),
+            Named.of("Value starting with a number ending with a single quote", "%1$dvalue'")),
+        Arguments.of(Named.of("Key ending with a number", "key%1$d"),
+            Named.of("Value starting & ending with a number", "%1$dvalue%1$d")),
+        Arguments.of(Named.of("Key starting with a single quote & ending with a number", "'key%1$d"),
+            Named.of("Value starting & ending with a number & elosed within quotes", "%1$d'value%1$d'")),
+        Arguments.of(Named.of("Key starting with a single quote & ending with a number", "'key%1$d"),
+            Named.of("Value starting & ending with a number & elosed within quotes", "%1$d'value%1$d'")),
+        Arguments.of(Named.of("Key ending with a number", "key%1$d"),
+            Named.of("Value starting & ending with a number & containing null character & new line character",
+                "%1$dvalue\n\0%1$d")),
+        Arguments.of(Named.of("Key ending with a number & containing a null character", "key\0%1$d"),
+            Named.of("Value starting & ending with a number & elosed within quotes", "%1$dvalue\r%1$d")));
+  }
+
+  @BeforeAll
+  public static void init() throws NativeLibraryNotLoadedException {
+    ManagedRawSSTFileReader.loadLibrary();
+  }
+
+
+  @ParameterizedTest
+  @MethodSource("keyValueFormatArgs")
+  public void testSSTDumpIteratorWithKeyFormat(String keyFormat, String valueFormat) throws Exception {
+    TreeMap<Pair<String, Integer>, String> keys = IntStream.range(0, 100).boxed().collect(Collectors.toMap(
+        i -> Pair.of(String.format(keyFormat, i), i % 2),
+        i -> i % 2 == 0 ? "" : String.format(valueFormat, i),
+        (v1, v2) -> v2,
+        TreeMap::new));
+    File file = createSSTFileWithKeys(keys);
+    try (ManagedOptions options = new ManagedOptions();
+         ManagedRawSSTFileReader<ManagedRawSSTFileIterator.KeyValue> reader = new ManagedRawSSTFileReader<>(
+             options, file.getAbsolutePath(), 2 * 1024 * 1024)) {
+      List<Optional<String>> testBounds = TestUtils.getTestingBounds(keys.keySet().stream()
+          .collect(Collectors.toMap(Pair::getKey, Pair::getValue, (v1, v2) -> v1, TreeMap::new)));
+      for (Optional<String> keyStart : testBounds) {
+        for (Optional<String> keyEnd : testBounds) {
+          Map<Pair<String, Integer>, String> expectedKeys = keys.entrySet().stream()
+              .filter(e -> keyStart.map(s -> e.getKey().getKey().compareTo(s) >= 0).orElse(true))
+              .filter(e -> keyEnd.map(s -> e.getKey().getKey().compareTo(s) < 0).orElse(true))
+              .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+          Optional<ManagedSlice> lowerBound = keyStart.map(s -> new ManagedSlice(StringUtils.string2Bytes(s)));
+          Optional<ManagedSlice> upperBound = keyEnd.map(s -> new ManagedSlice(StringUtils.string2Bytes(s)));
+          try (ManagedRawSSTFileIterator<ManagedRawSSTFileIterator.KeyValue> iterator
+                   = reader.newIterator(Function.identity(), lowerBound.orElse(null), upperBound.orElse(null))) {
+            while (iterator.hasNext()) {
+              ManagedRawSSTFileIterator.KeyValue r = iterator.next();
+              String key = StringUtils.bytes2String(r.getKey());
+              Pair<String, Integer> recordKey = Pair.of(key, r.getType());
+              assertThat(expectedKeys).containsKey(recordKey);
+              assertEquals(Optional.ofNullable(expectedKeys.get(recordKey)).orElse(""),
+                  StringUtils.bytes2String(r.getValue()));
+              expectedKeys.remove(recordKey);
+            }
+            assertEquals(0, expectedKeys.size());
+          } finally {
+            lowerBound.ifPresent(ManagedSlice::close);
+            upperBound.ifPresent(ManagedSlice::close);
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedSSTDumpIterator.java b/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedSSTDumpIterator.java
deleted file mode 100644
index 99d2a6ced59f..000000000000
--- a/hadoop-hdds/rocks-native/src/test/java/org/apache/hadoop/hdds/utils/db/managed/TestManagedSSTDumpIterator.java
+++ /dev/null
@@ -1,275 +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
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * 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.utils.db.managed;
-
-import com.google.common.primitives.Bytes;
-import org.apache.commons.lang3.tuple.Pair;
-import org.apache.hadoop.hdds.StringUtils;
-import org.apache.hadoop.hdds.utils.NativeLibraryLoader;
-import org.apache.hadoop.hdds.utils.TestUtils;
-import org.apache.ozone.test.tag.Native;
-import org.apache.ozone.test.tag.Unhealthy;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Assumptions;
-import org.junit.jupiter.api.Named;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Matchers;
-import org.mockito.Mockito;
-
-import java.io.ByteArrayInputStream;
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.TreeMap;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
-
-import static org.apache.hadoop.hdds.utils.NativeConstants.ROCKS_TOOLS_NATIVE_LIBRARY_NAME;
-
-/**
- * Test for ManagedSSTDumpIterator.
- */
-class TestManagedSSTDumpIterator {
-
-  private File createSSTFileWithKeys(
-      TreeMap<Pair<String, Integer>, String> keys) throws Exception {
-    File file = File.createTempFile("tmp_sst_file", ".sst");
-    file.deleteOnExit();
-    try (ManagedEnvOptions envOptions = new ManagedEnvOptions();
-         ManagedOptions managedOptions = new ManagedOptions();
-         ManagedSstFileWriter sstFileWriter = new ManagedSstFileWriter(
-             envOptions, managedOptions)) {
-      sstFileWriter.open(file.getAbsolutePath());
-      for (Map.Entry<Pair<String, Integer>, String> entry : keys.entrySet()) {
-        if (entry.getKey().getValue() == 0) {
-          sstFileWriter.delete(entry.getKey().getKey()
-              .getBytes(StandardCharsets.UTF_8));
-        } else {
-          sstFileWriter.put(entry.getKey().getKey()
-                  .getBytes(StandardCharsets.UTF_8),
-              entry.getValue().getBytes(StandardCharsets.UTF_8));
-        }
-      }
-      sstFileWriter.finish();
-    }
-    return file;
-  }
-
-  private static Stream<? extends Arguments> keyValueFormatArgs() {
-    return Stream.of(
-        Arguments.of(
-            Named.of("Key starting with a single quote",
-                "'key%1$d=>"),
-            Named.of("Value starting with a number ending with a" +
-                " single quote", "%1$dvalue'")
-        ),
-        Arguments.of(
-            Named.of("Key ending with a number", "key%1$d"),
-            Named.of("Value starting & ending with a number", "%1$dvalue%1$d")
-        ),
-        Arguments.of(
-            Named.of("Key starting with a single quote & ending" +
-                " with a number", "'key%1$d"),
-            Named.of("Value starting & ending with a number " +
-                "& elosed within quotes", "%1$d'value%1$d'")),
-        Arguments.of(
-            Named.of("Key starting with a single quote & ending" +
-                " with a number", "'key%1$d"),
-            Named.of("Value starting & ending with a number " +
-                "& elosed within quotes", "%1$d'value%1$d'")
-        ),
-        Arguments.of(
-            Named.of("Key ending with a number", "key%1$d"),
-            Named.of("Value starting & ending with a number " +
-                    "& containing null character & new line character",
-                "%1$dvalue\n\0%1$d")
-        ),
-        Arguments.of(
-            Named.of("Key ending with a number & containing" +
-                " a null character", "key\0%1$d"),
-            Named.of("Value starting & ending with a number " +
-                "& elosed within quotes", "%1$dvalue\r%1$d")
-        )
-    );
-  }
-
-  private static byte[] getBytes(Integer val) {
-    ByteBuffer destByteBuffer = ByteBuffer.allocate(4);
-    destByteBuffer.order(ByteOrder.BIG_ENDIAN);
-    destByteBuffer.putInt(val);
-    return destByteBuffer.array();
-  }
-
-  private static byte[] getBytes(Long val) {
-    ByteBuffer destByteBuffer = ByteBuffer.allocate(8);
-    destByteBuffer.order(ByteOrder.BIG_ENDIAN);
-    destByteBuffer.putLong(val);
-    return destByteBuffer.array();
-  }
-
-  private static byte[] getBytes(String val) {
-    byte[] b = new byte[val.length()];
-    for (int i = 0; i < val.length(); i++) {
-      b[i] = (byte) val.charAt(i);
-    }
-    return b;
-  }
-
-  private static Stream<? extends Arguments> invalidPipeInputStreamBytes() {
-    return Stream.of(
-        Arguments.of(Named.of("Invalid 3 byte integer",
-            new byte[]{0, 0, 0})),
-        Arguments.of(Named.of("Invalid 2 byte integer",
-            new byte[]{0, 0})),
-        Arguments.of(Named.of("Invalid 1 byte integer",
-            new byte[]{0, 0})),
-        Arguments.of(Named.of("Invalid key name length",
-            Bytes.concat(getBytes(4), getBytes("key")))),
-        Arguments.of(Named.of("Invalid Unsigned Long length",
-            Bytes.concat(getBytes(4), getBytes("key1"),
-                new byte[]{0, 0}))),
-        Arguments.of(Named.of("Invalid Sequence number",
-            Bytes.concat(getBytes(4), getBytes("key1")))),
-        Arguments.of(Named.of("Invalid Type",
-            Bytes.concat(getBytes(4), getBytes("key1"),
-                getBytes(4L)))),
-        Arguments.of(Named.of("Invalid Value",
-            Bytes.concat(getBytes(4), getBytes("key"),
-                getBytes(4L), getBytes(0)))),
-        Arguments.of(Named.of("Invalid Value length",
-            Bytes.concat(getBytes(4), getBytes("key"),
-                getBytes(4L), getBytes(1), getBytes(6),
-                getBytes("val"))))
-    );
-  }
-
-  @Native(ROCKS_TOOLS_NATIVE_LIBRARY_NAME)
-  @ParameterizedTest
-  @MethodSource("keyValueFormatArgs")
-  @Unhealthy("HDDS-9274")
-  public void testSSTDumpIteratorWithKeyFormat(String keyFormat,
-                                               String valueFormat)
-      throws Exception {
-    Assumptions.assumeTrue(NativeLibraryLoader.getInstance()
-        .loadLibrary(ROCKS_TOOLS_NATIVE_LIBRARY_NAME));
-
-    TreeMap<Pair<String, Integer>, String> keys =
-        IntStream.range(0, 100).boxed().collect(
-            Collectors.toMap(
-                i -> Pair.of(String.format(keyFormat, i), i % 2),
-                i -> i % 2 == 0 ? "" : String.format(valueFormat, i),
-                (v1, v2) -> v2,
-                TreeMap::new));
-    File file = createSSTFileWithKeys(keys);
-    ExecutorService executorService =
-        new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS,
-            new ArrayBlockingQueue<>(1),
-            new ThreadPoolExecutor.CallerRunsPolicy());
-    ManagedSSTDumpTool tool = new ManagedSSTDumpTool(executorService, 8192);
-    List<Optional<String>> testBounds = TestUtils.getTestingBounds(
-        keys.keySet().stream().collect(Collectors.toMap(Pair::getKey,
-            Pair::getValue, (v1, v2) -> v1, TreeMap::new)));
-    for (Optional<String> keyStart : testBounds) {
-      for (Optional<String> keyEnd : testBounds) {
-        Map<Pair<String, Integer>, String> expectedKeys = keys.entrySet()
-            .stream().filter(e -> keyStart.map(s -> e.getKey().getKey()
-                .compareTo(s) >= 0).orElse(true))
-            .filter(e -> keyEnd.map(s -> e.getKey().getKey().compareTo(s) < 0)
-                .orElse(true))
-            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-        Optional<ManagedSlice> lowerBound = keyStart
-            .map(s -> new ManagedSlice(StringUtils.string2Bytes(s)));
-        Optional<ManagedSlice> upperBound = keyEnd
-            .map(s -> new ManagedSlice(StringUtils.string2Bytes(s)));
-        try (ManagedOptions options = new ManagedOptions();
-             ManagedSSTDumpIterator<ManagedSSTDumpIterator.KeyValue> iterator =
-            new ManagedSSTDumpIterator<ManagedSSTDumpIterator.KeyValue>(tool,
-                file.getAbsolutePath(), options, lowerBound.orElse(null),
-                upperBound.orElse(null)) {
-              @Override
-              protected KeyValue getTransformedValue(
-                  Optional<KeyValue> value) {
-                return value.orElse(null);
-              }
-            }
-        ) {
-          while (iterator.hasNext()) {
-            ManagedSSTDumpIterator.KeyValue r = iterator.next();
-            String key = new String(r.getKey(), StandardCharsets.UTF_8);
-            Pair<String, Integer> recordKey = Pair.of(key, r.getType());
-            Assertions.assertTrue(expectedKeys.containsKey(recordKey));
-            Assertions.assertEquals(Optional.ofNullable(expectedKeys
-                    .get(recordKey)).orElse(""),
-                new String(r.getValue(), StandardCharsets.UTF_8));
-            expectedKeys.remove(recordKey);
-          }
-          Assertions.assertEquals(0, expectedKeys.size());
-        } finally {
-          lowerBound.ifPresent(ManagedSlice::close);
-          upperBound.ifPresent(ManagedSlice::close);
-        }
-      }
-    }
-    executorService.shutdown();
-  }
-
-
-  @ParameterizedTest
-  @MethodSource("invalidPipeInputStreamBytes")
-  public void testInvalidSSTDumpIteratorWithKeyFormat(byte[] inputBytes)
-      throws ExecutionException,
-      InterruptedException, IOException {
-    ByteArrayInputStream byteArrayInputStream =
-        new ByteArrayInputStream(inputBytes);
-    ManagedSSTDumpTool tool = Mockito.mock(ManagedSSTDumpTool.class);
-    File file = File.createTempFile("tmp", ".sst");
-    Future future = Mockito.mock(Future.class);
-    Mockito.when(future.isDone()).thenReturn(false);
-    Mockito.when(future.get()).thenReturn(0);
-    Mockito.when(tool.run(Matchers.any(Map.class),
-            Matchers.any(ManagedOptions.class)))
-        .thenReturn(new ManagedSSTDumpTool.SSTDumpToolTask(future,
-            byteArrayInputStream));
-    try (ManagedOptions options = new ManagedOptions()) {
-      Assertions.assertThrows(IllegalStateException.class,
-          () -> new ManagedSSTDumpIterator<ManagedSSTDumpIterator.KeyValue>(
-              tool, file.getAbsolutePath(), options) {
-            @Override
-            protected KeyValue getTransformedValue(
-                Optional<KeyValue> value) {
-              return value.orElse(null);
-            }
-          });
-    }
-  }
-}
diff --git a/hadoop-hdds/rocks-native/src/test/resources/auditlog.properties b/hadoop-hdds/rocks-native/src/test/resources/auditlog.properties
new file mode 100644
index 000000000000..959da047fb7f
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/test/resources/auditlog.properties
@@ -0,0 +1,76 @@
+#
+# 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
+# <p>
+# http://www.apache.org/licenses/LICENSE-2.0
+# <p>
+# 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.
+#
+name=PropertiesConfig
+
+# Checks for config change periodically and reloads
+monitorInterval=5
+
+filter=read, write
+# filter.read.onMatch = DENY avoids logging all READ events
+# filter.read.onMatch = ACCEPT permits logging all READ events
+# The above two settings ignore the log levels in configuration
+# filter.read.onMatch = NEUTRAL permits logging of only those READ events
+# which are attempted at log level equal or greater than log level specified
+# in the configuration
+filter.read.type = MarkerFilter
+filter.read.marker = READ
+filter.read.onMatch = NEUTRAL
+filter.read.onMismatch = NEUTRAL
+
+# filter.write.onMatch = DENY avoids logging all WRITE events
+# filter.write.onMatch = ACCEPT permits logging all WRITE events
+# The above two settings ignore the log levels in configuration
+# filter.write.onMatch = NEUTRAL permits logging of only those WRITE events
+# which are attempted at log level equal or greater than log level specified
+# in the configuration
+filter.write.type = MarkerFilter
+filter.write.marker = WRITE
+filter.write.onMatch = NEUTRAL
+filter.write.onMismatch = NEUTRAL
+
+# Log Levels are organized from most specific to least:
+# OFF (most specific, no logging)
+# FATAL (most specific, little data)
+# ERROR
+# WARN
+# INFO
+# DEBUG
+# TRACE (least specific, a lot of data)
+# ALL (least specific, all data)
+
+appenders = console, audit
+appender.console.type = Console
+appender.console.name = STDOUT
+appender.console.layout.type = PatternLayout
+appender.console.layout.pattern = %-5level | %c{1} | %msg%n
+
+appender.audit.type = File
+appender.audit.name = AUDITLOG
+appender.audit.fileName=audit.log
+appender.audit.layout.type=PatternLayout
+appender.audit.layout.pattern= %-5level | %c{1} | %C | %msg%n
+
+loggers=audit
+logger.audit.type=AsyncLogger
+logger.audit.name=OMAudit
+logger.audit.level = INFO
+logger.audit.appenderRefs = audit
+logger.audit.appenderRef.file.ref = AUDITLOG
+
+rootLogger.level = INFO
+rootLogger.appenderRefs = stdout
+rootLogger.appenderRef.stdout.ref = STDOUT
diff --git a/hadoop-hdds/rocks-native/src/test/resources/log4j.properties b/hadoop-hdds/rocks-native/src/test/resources/log4j.properties
new file mode 100644
index 000000000000..398786689af3
--- /dev/null
+++ b/hadoop-hdds/rocks-native/src/test/resources/log4j.properties
@@ -0,0 +1,23 @@
+#
+#   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.
+#
+# log4j configuration used during build and unit tests
+
+log4j.rootLogger=INFO,stdout
+log4j.threshold=ALL
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{ISO8601} [%t] %-5p %c{2} (%F:%M(%L)) - %m%n
diff --git a/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdb/util/SstFileSetReader.java b/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdb/util/SstFileSetReader.java
index 5a1df61b4436..058d3d955315 100644
--- a/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdb/util/SstFileSetReader.java
+++ b/hadoop-hdds/rocksdb-checkpoint-differ/src/main/java/org/apache/ozone/rocksdb/util/SstFileSetReader.java
@@ -20,14 +20,14 @@
 
 import org.apache.hadoop.hdds.StringUtils;
 import org.apache.hadoop.hdds.utils.IOUtils;
+import org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileIterator;
+import org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileReader;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedSlice;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedSstFileReader;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedSstFileReaderIterator;
 import org.apache.hadoop.util.ClosableIterator;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedOptions;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedReadOptions;
-import org.apache.hadoop.hdds.utils.db.managed.ManagedSSTDumpIterator;
-import org.apache.hadoop.hdds.utils.db.managed.ManagedSSTDumpTool;
 import org.rocksdb.RocksDBException;
 
 import java.io.IOException;
@@ -36,9 +36,9 @@
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Spliterator;
 import java.util.Spliterators;
+import java.util.function.Function;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
@@ -90,100 +90,87 @@ public long getEstimatedTotalKeys() throws RocksDBException {
   }
 
   public Stream<String> getKeyStream(String lowerBound,
-      String upperBound) throws RocksDBException {
+                                     String upperBound) throws RocksDBException {
     // TODO: [SNAPSHOT] Check if default Options and ReadOptions is enough.
-    final MultipleSstFileIterator<String> itr =
-        new MultipleSstFileIterator<String>(sstFiles) {
-          private ManagedOptions options;
-          private ManagedReadOptions readOptions;
-
-          private ManagedSlice lowerBoundSLice;
-
-          private ManagedSlice upperBoundSlice;
-
-          @Override
-          protected void init() {
-            this.options = new ManagedOptions();
-            this.readOptions = new ManagedReadOptions();
-            if (Objects.nonNull(lowerBound)) {
-              this.lowerBoundSLice = new ManagedSlice(
-                  StringUtils.string2Bytes(lowerBound));
-              readOptions.setIterateLowerBound(lowerBoundSLice);
-            }
-
-            if (Objects.nonNull(upperBound)) {
-              this.upperBoundSlice = new ManagedSlice(
-                  StringUtils.string2Bytes(upperBound));
-              readOptions.setIterateUpperBound(upperBoundSlice);
-            }
-          }
+    final MultipleSstFileIterator<String> itr = new MultipleSstFileIterator<String>(sstFiles) {
+      private ManagedOptions options;
+      private ManagedReadOptions readOptions;
+
+      private ManagedSlice lowerBoundSLice;
+
+      private ManagedSlice upperBoundSlice;
+
+      @Override
+      protected void init() {
+        this.options = new ManagedOptions();
+        this.readOptions = new ManagedReadOptions();
+        if (Objects.nonNull(lowerBound)) {
+          this.lowerBoundSLice = new ManagedSlice(
+              StringUtils.string2Bytes(lowerBound));
+          readOptions.setIterateLowerBound(lowerBoundSLice);
+        }
 
-          @Override
-          protected ClosableIterator<String> getKeyIteratorForFile(String file)
-              throws RocksDBException {
-            return new ManagedSstFileIterator(file, options, readOptions) {
-              @Override
-              protected String getIteratorValue(
-                  ManagedSstFileReaderIterator iterator) {
-                return new String(iterator.get().key(), UTF_8);
-              }
-            };
-          }
+        if (Objects.nonNull(upperBound)) {
+          this.upperBoundSlice = new ManagedSlice(
+              StringUtils.string2Bytes(upperBound));
+          readOptions.setIterateUpperBound(upperBoundSlice);
+        }
+      }
 
+      @Override
+      protected ClosableIterator<String> getKeyIteratorForFile(String file) throws RocksDBException {
+        return new ManagedSstFileIterator(file, options, readOptions) {
           @Override
-          public void close() throws UncheckedIOException {
-            super.close();
-            options.close();
-            readOptions.close();
-            IOUtils.closeQuietly(lowerBoundSLice, upperBoundSlice);
+          protected String getIteratorValue(ManagedSstFileReaderIterator iterator) {
+            return new String(iterator.get().key(), UTF_8);
           }
         };
+      }
+
+      @Override
+      public void close() throws UncheckedIOException {
+        super.close();
+        options.close();
+        readOptions.close();
+        IOUtils.closeQuietly(lowerBoundSLice, upperBoundSlice);
+      }
+    };
     return getStreamFromIterator(itr);
   }
 
-  public Stream<String> getKeyStreamWithTombstone(
-      ManagedSSTDumpTool sstDumpTool, String lowerBound,
-      String upperBound) throws RocksDBException {
-    final MultipleSstFileIterator<String> itr =
-        new MultipleSstFileIterator<String>(sstFiles) {
-          //TODO: [SNAPSHOT] Check if default Options is enough.
-          private ManagedOptions options;
-          private ManagedSlice lowerBoundSlice;
-          private ManagedSlice upperBoundSlice;
-
-          @Override
-          protected void init() {
-            this.options = new ManagedOptions();
-            if (Objects.nonNull(lowerBound)) {
-              this.lowerBoundSlice = new ManagedSlice(
-                  StringUtils.string2Bytes(lowerBound));
-            }
-            if (Objects.nonNull(upperBound)) {
-              this.upperBoundSlice = new ManagedSlice(
-                  StringUtils.string2Bytes(upperBound));
-            }
-          }
+  public Stream<String> getKeyStreamWithTombstone(String lowerBound, String upperBound) throws RocksDBException {
+    final MultipleSstFileIterator<String> itr = new MultipleSstFileIterator<String>(sstFiles) {
+      //TODO: [SNAPSHOT] Check if default Options is enough.
+      private ManagedOptions options;
+      private ManagedSlice lowerBoundSlice;
+      private ManagedSlice upperBoundSlice;
+
+      @Override
+      protected void init() {
+        this.options = new ManagedOptions();
+        if (Objects.nonNull(lowerBound)) {
+          this.lowerBoundSlice = new ManagedSlice(
+              StringUtils.string2Bytes(lowerBound));
+        }
+        if (Objects.nonNull(upperBound)) {
+          this.upperBoundSlice = new ManagedSlice(
+              StringUtils.string2Bytes(upperBound));
+        }
+      }
 
-          @Override
-          protected ClosableIterator<String> getKeyIteratorForFile(String file)
-              throws IOException {
-            return new ManagedSSTDumpIterator<String>(sstDumpTool, file,
-                options, lowerBoundSlice, upperBoundSlice) {
-              @Override
-              protected String getTransformedValue(Optional<KeyValue> value) {
-                return value.map(v -> StringUtils.bytes2String(v.getKey()))
-                    .orElse(null);
-              }
-            };
-          }
+      @Override
+      protected ClosableIterator<String> getKeyIteratorForFile(String file) {
+        return new ManagedRawSstFileIterator(file, options, lowerBoundSlice, upperBoundSlice,
+            keyValue -> StringUtils.bytes2String(keyValue.getKey()));
+      }
 
-          @Override
-          public void close() throws UncheckedIOException {
-            super.close();
-            options.close();
-            IOUtils.closeQuietly(lowerBoundSlice, upperBoundSlice);
-          }
-        };
+      @Override
+      public void close() throws UncheckedIOException {
+        super.close();
+        options.close();
+        IOUtils.closeQuietly(lowerBoundSlice, upperBoundSlice);
+      }
+    };
     return getStreamFromIterator(itr);
   }
 
@@ -191,8 +178,7 @@ private abstract static class ManagedSstFileIterator implements ClosableIterator
     private final ManagedSstFileReader fileReader;
     private final ManagedSstFileReaderIterator fileReaderIterator;
 
-    ManagedSstFileIterator(String path, ManagedOptions options,
-                           ManagedReadOptions readOptions)
+    ManagedSstFileIterator(String path, ManagedOptions options, ManagedReadOptions readOptions)
         throws RocksDBException {
       this.fileReader = new ManagedSstFileReader(options);
       this.fileReader.open(path);
@@ -221,8 +207,35 @@ public String next() {
     }
   }
 
-  private abstract static class MultipleSstFileIterator<T> implements
-      ClosableIterator<T> {
+  private static class ManagedRawSstFileIterator implements ClosableIterator<String> {
+    private final ManagedRawSSTFileReader<String> fileReader;
+    private final ManagedRawSSTFileIterator<String> fileReaderIterator;
+    private static final int READ_AHEAD_SIZE = 2 * 1024 * 1024;
+
+    ManagedRawSstFileIterator(String path, ManagedOptions options, ManagedSlice lowerBound, ManagedSlice upperBound,
+                              Function<ManagedRawSSTFileIterator.KeyValue, String> keyValueFunction) {
+      this.fileReader = new ManagedRawSSTFileReader<>(options, path, READ_AHEAD_SIZE);
+      this.fileReaderIterator = fileReader.newIterator(keyValueFunction, lowerBound, upperBound);
+    }
+
+    @Override
+    public void close() {
+      this.fileReaderIterator.close();
+      this.fileReader.close();
+    }
+
+    @Override
+    public boolean hasNext() {
+      return fileReaderIterator.hasNext();
+    }
+
+    @Override
+    public String next() {
+      return fileReaderIterator.next();
+    }
+  }
+
+  private abstract static class MultipleSstFileIterator<T> implements ClosableIterator<T> {
 
     private final Iterator<String> fileNameIterator;
 
@@ -236,16 +249,13 @@ private MultipleSstFileIterator(Collection<String> files) {
 
     protected abstract void init();
 
-    protected abstract ClosableIterator<T> getKeyIteratorForFile(String file)
-        throws RocksDBException,
-        IOException;
+    protected abstract ClosableIterator<T> getKeyIteratorForFile(String file) throws RocksDBException, IOException;
 
     @Override
     public boolean hasNext() {
       try {
         do {
-          if (Objects.nonNull(currentFileIterator) &&
-              currentFileIterator.hasNext()) {
+          if (Objects.nonNull(currentFileIterator) && currentFileIterator.hasNext()) {
             return true;
           }
         } while (moveToNextFile());
diff --git a/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdb/util/TestSstFileSetReader.java b/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdb/util/TestSstFileSetReader.java
index 676a3e35c04c..51bc7e7e3dd3 100644
--- a/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdb/util/TestSstFileSetReader.java
+++ b/hadoop-hdds/rocksdb-checkpoint-differ/src/test/java/org/apache/ozone/rocksdb/util/TestSstFileSetReader.java
@@ -17,18 +17,15 @@
  */
 package org.apache.ozone.rocksdb.util;
 
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.hadoop.hdds.StringUtils;
-import org.apache.hadoop.hdds.utils.NativeLibraryLoader;
 import org.apache.hadoop.hdds.utils.NativeLibraryNotLoadedException;
 import org.apache.hadoop.hdds.utils.TestUtils;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedEnvOptions;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedOptions;
-import org.apache.hadoop.hdds.utils.db.managed.ManagedSSTDumpTool;
+import org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileReader;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedSstFileWriter;
 import org.apache.ozone.test.tag.Native;
-import org.apache.ozone.test.tag.Unhealthy;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -43,10 +40,6 @@
 import java.util.Optional;
 import java.util.SortedMap;
 import java.util.TreeMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.SynchronousQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
@@ -155,51 +148,38 @@ public void testGetKeyStream(int numberOfFiles)
   @Native(ROCKS_TOOLS_NATIVE_LIBRARY_NAME)
   @ParameterizedTest
   @ValueSource(ints = {0, 1, 2, 3, 7, 10})
-  @Unhealthy("HDDS-9274")
   public void testGetKeyStreamWithTombstone(int numberOfFiles)
       throws RocksDBException, IOException, NativeLibraryNotLoadedException {
-    Assumptions.assumeTrue(NativeLibraryLoader.getInstance()
-        .loadLibrary(ROCKS_TOOLS_NATIVE_LIBRARY_NAME));
+    Assumptions.assumeTrue(ManagedRawSSTFileReader.loadLibrary());
     Pair<SortedMap<String, Integer>, List<String>> data =
         createDummyData(numberOfFiles);
     List<String> files = data.getRight();
     SortedMap<String, Integer> keys = data.getLeft();
-    ExecutorService executorService = new ThreadPoolExecutor(0,
-        2, 60, TimeUnit.SECONDS,
-        new SynchronousQueue<>(), new ThreadFactoryBuilder()
-        .setNameFormat("snapshot-diff-manager-sst-dump-tool-TID-%d")
-        .build(), new ThreadPoolExecutor.DiscardPolicy());
-    ManagedSSTDumpTool sstDumpTool =
-        new ManagedSSTDumpTool(executorService, 256);
     // Getting every possible combination of 2 elements from the sampled keys.
     // Reading the sst file lying within the given bounds and
     // validating the keys read from the sst file.
     List<Optional<String>> bounds = TestUtils.getTestingBounds(keys);
-    try {
-      for (Optional<String> lowerBound : bounds) {
-        for (Optional<String> upperBound : bounds) {
-          // Calculating the expected keys which lie in the given boundary.
-          Map<String, Integer> keysInBoundary =
-              keys.entrySet().stream().filter(entry -> lowerBound
-                      .map(l -> entry.getKey().compareTo(l) >= 0)
-                      .orElse(true)  &&
-                      upperBound.map(u -> entry.getKey().compareTo(u) < 0)
-                          .orElse(true))
-                  .collect(Collectors.toMap(Map.Entry::getKey,
-                      Map.Entry::getValue));
-          try (Stream<String> keyStream = new SstFileSetReader(files)
-              .getKeyStreamWithTombstone(sstDumpTool, lowerBound.orElse(null),
-                  upperBound.orElse(null))) {
-            keyStream.forEach(
-                key -> {
-                  Assertions.assertNotNull(keysInBoundary.remove(key));
-                });
-          }
-          Assertions.assertEquals(0, keysInBoundary.size());
+    for (Optional<String> lowerBound : bounds) {
+      for (Optional<String> upperBound : bounds) {
+        // Calculating the expected keys which lie in the given boundary.
+        Map<String, Integer> keysInBoundary =
+            keys.entrySet().stream().filter(entry -> lowerBound
+                    .map(l -> entry.getKey().compareTo(l) >= 0)
+                    .orElse(true)  &&
+                    upperBound.map(u -> entry.getKey().compareTo(u) < 0)
+                        .orElse(true))
+                .collect(Collectors.toMap(Map.Entry::getKey,
+                    Map.Entry::getValue));
+        try (Stream<String> keyStream = new SstFileSetReader(files)
+            .getKeyStreamWithTombstone(lowerBound.orElse(null),
+                upperBound.orElse(null))) {
+          keyStream.forEach(
+              key -> {
+                Assertions.assertNotNull(keysInBoundary.remove(key));
+              });
         }
+        Assertions.assertEquals(0, keysInBoundary.size());
       }
-    } finally {
-      executorService.shutdown();
     }
   }
 }
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 9b844cc74fdf..519edf20f139 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
@@ -28,21 +28,9 @@
  * Ozone Manager Constants.
  */
 public final class OMConfigKeys {
-  public static final String
-      OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE =
-      "ozone.om.snapshot.sst_dumptool.pool.size";
-  public static final int
-      OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE_DEFAULT = 1;
-
   public static final String OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB =
       "ozone.om.snapshot.load.native.lib";
   public static final boolean OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT = true;
-  public static final String
-      OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE =
-      "ozone.om.snapshot.sst_dumptool.buffer.size";
-  public static final String
-      OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE_DEFAULT = "8KB";
-
   /**
    * Never constructed.
    */
diff --git a/hadoop-ozone/dev-support/checks/native.sh b/hadoop-ozone/dev-support/checks/native.sh
index 4d22e695e76f..89206b3bdf2f 100755
--- a/hadoop-ozone/dev-support/checks/native.sh
+++ b/hadoop-ozone/dev-support/checks/native.sh
@@ -19,13 +19,5 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 CHECK=native
 
-zlib_version=$(mvn -N help:evaluate -Dexpression=zlib.version -q -DforceStdout)
-if [[ -z "${zlib_version}" ]]; then
-  echo "ERROR zlib.version not defined in pom.xml"
-  exit 1
-fi
-
-source "${DIR}/junit.sh" -Pnative -Drocks_tools_native \
-  -Dzlib.url="https://github.com/madler/zlib/releases/download/v${zlib_version}/zlib-${zlib_version}.tar.gz" \
-  -DexcludedGroups="unhealthy | org.apache.ozone.test.UnhealthyTest" \
+source "${DIR}/junit.sh" -Pnative -Drocks_tools_native -DexcludedGroups="unhealthy" \
   "$@"
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
index eb9fbc5ca2e6..e67a6b0d6f44 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/snapshot/SnapshotDiffManager.java
@@ -25,18 +25,16 @@
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.hadoop.hdds.StringUtils;
 import org.apache.hadoop.hdds.conf.OzoneConfiguration;
-import org.apache.hadoop.hdds.conf.StorageUnit;
 import org.apache.hadoop.hdds.utils.NativeLibraryNotLoadedException;
 import org.apache.hadoop.hdds.utils.db.CodecRegistry;
 import org.apache.hadoop.hdds.utils.db.RDBStore;
 import org.apache.hadoop.hdds.utils.db.Table;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedColumnFamilyOptions;
+import org.apache.hadoop.hdds.utils.db.managed.ManagedRawSSTFileReader;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedRocksDB;
-import org.apache.hadoop.hdds.utils.db.managed.ManagedSSTDumpTool;
 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport.DiffReportEntry;
 import org.apache.hadoop.ozone.OFSPath;
 import org.apache.hadoop.ozone.OzoneConsts;
-import org.apache.hadoop.ozone.om.OMConfigKeys;
 import org.apache.hadoop.ozone.om.OMMetadataManager;
 import org.apache.hadoop.ozone.om.OmMetadataManagerImpl;
 import org.apache.hadoop.ozone.om.OmSnapshot;
@@ -88,7 +86,6 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
@@ -111,6 +108,8 @@
 import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_FORCE_FULL_DIFF_DEFAULT;
 import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_DIFF_DISABLE_NATIVE_LIBS;
 import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_DIFF_DISABLE_NATIVE_LIBS_DEFAULT;
+import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB;
+import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT;
 import static org.apache.hadoop.ozone.om.OmMetadataManagerImpl.DIRECTORY_TABLE;
 import static org.apache.hadoop.ozone.om.OmSnapshotManager.DELIMITER;
 import static org.apache.hadoop.ozone.om.snapshot.SnapshotUtils.checkSnapshotActive;
@@ -182,9 +181,7 @@ public class SnapshotDiffManager implements AutoCloseable {
 
   private final boolean diffDisableNativeLibs;
 
-  private final Optional<ManagedSSTDumpTool> sstDumpTool;
-
-  private Optional<ExecutorService> sstDumpToolExecService;
+  private final boolean isNativeLibsLoaded;
 
   private final BiFunction<SnapshotInfo, SnapshotInfo, String>
       generateSnapDiffJobKey =
@@ -259,7 +256,7 @@ public SnapshotDiffManager(ManagedRocksDB db,
     createEmptySnapDiffDir(path);
     this.sstBackupDirForSnapDiffJobs = path.toString();
 
-    this.sstDumpTool = initSSTDumpTool(ozoneManager.getConfiguration());
+    this.isNativeLibsLoaded = initNativeLibraryForEfficientDiff(ozoneManager.getConfiguration());
 
     // Ideally, loadJobsOnStartUp should run only on OM node, since SnapDiff
     // is not HA currently and running this on all the nodes would be
@@ -282,35 +279,16 @@ public PersistentMap<String, SnapshotDiffJob> getSnapDiffJobTable() {
     return snapDiffJobTable;
   }
 
-  private Optional<ManagedSSTDumpTool> initSSTDumpTool(
-      final OzoneConfiguration conf) {
-    if (conf.getBoolean(OMConfigKeys.OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB,
-        OMConfigKeys.OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT)) {
+  private boolean initNativeLibraryForEfficientDiff(final OzoneConfiguration conf) {
+    if (conf.getBoolean(OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB, OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT)) {
       try {
-        int threadPoolSize = conf.getInt(
-                OMConfigKeys.OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE,
-                OMConfigKeys
-                    .OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE_DEFAULT);
-        int bufferSize = (int) conf.getStorageSize(
-            OMConfigKeys.OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE,
-            OMConfigKeys
-                .OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE_DEFAULT,
-                StorageUnit.BYTES);
-        this.sstDumpToolExecService = Optional.of(new ThreadPoolExecutor(0,
-                threadPoolSize, 60, TimeUnit.SECONDS,
-                new SynchronousQueue<>(), new ThreadFactoryBuilder()
-            .setNameFormat(ozoneManager.getThreadNamePrefix() +
-                "snapshot-diff-manager-sst-dump-tool-TID-%d")
-                .build(),
-                new ThreadPoolExecutor.DiscardPolicy()));
-        return Optional.of(new ManagedSSTDumpTool(sstDumpToolExecService.get(),
-            bufferSize));
+        return ManagedRawSSTFileReader.loadLibrary();
       } catch (NativeLibraryNotLoadedException e) {
-        this.sstDumpToolExecService.ifPresent(exec ->
-            closeExecutorService(exec, "SstDumpToolExecutor"));
+        LOG.error("Native Library for raw sst file reading loading failed.", e);
+        return false;
       }
     }
-    return Optional.empty();
+    return false;
   }
 
   /**
@@ -1052,12 +1030,12 @@ private void getDeltaFilesAndDiffKeysToObjectIdToKeyMap(
     // Workaround to handle deletes if native rocksDb tool for reading
     // tombstone is not loaded.
     // TODO: [SNAPSHOT] Update Rocksdb SSTFileIterator to read tombstone
-    if (skipNativeDiff || !sstDumpTool.isPresent()) {
+    if (skipNativeDiff || !isNativeLibsLoaded) {
       deltaFiles.addAll(getSSTFileListForSnapshot(fromSnapshot,
           tablesToLookUp));
     }
     addToObjectIdMap(fsTable, tsTable, deltaFiles,
-        !skipNativeDiff && sstDumpTool.isPresent(),
+        !skipNativeDiff && isNativeLibsLoaded,
         oldObjIdToKeyMap, newObjIdToKeyMap, objectIdToIsDirMap, oldParentIds,
         newParentIds, tablePrefixes);
   }
@@ -1088,12 +1066,9 @@ void addToObjectIdMap(Table<String, ? extends WithParentObjectId> fsTable,
       upperBoundCharArray[upperBoundCharArray.length - 1] += 1;
       sstFileReaderUpperBound = String.valueOf(upperBoundCharArray);
     }
-    try (Stream<String> keysToCheck =
-             nativeRocksToolsLoaded && sstDumpTool.isPresent()
-                 ? sstFileReader.getKeyStreamWithTombstone(sstDumpTool.get(),
-                 sstFileReaderLowerBound, sstFileReaderUpperBound)
-                 : sstFileReader.getKeyStream(sstFileReaderLowerBound,
-                 sstFileReaderUpperBound)) {
+    try (Stream<String> keysToCheck = nativeRocksToolsLoaded ?
+        sstFileReader.getKeyStreamWithTombstone(sstFileReaderLowerBound, sstFileReaderUpperBound)
+        : sstFileReader.getKeyStream(sstFileReaderLowerBound, sstFileReaderUpperBound)) {
       keysToCheck.forEach(key -> {
         try {
           final WithParentObjectId fromObjectId = fsTable.get(key);
@@ -1674,8 +1649,6 @@ public void close() {
     if (snapDiffExecutor != null) {
       closeExecutorService(snapDiffExecutor, "SnapDiffExecutor");
     }
-    this.sstDumpToolExecService.ifPresent(exec ->
-        closeExecutorService(exec, "SstDumpToolExecutor"));
   }
 
   private void closeExecutorService(ExecutorService executorService,
diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/snapshot/TestSnapshotDiffManager.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/snapshot/TestSnapshotDiffManager.java
index 786ab385ac39..b70704ce2c6d 100644
--- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/snapshot/TestSnapshotDiffManager.java
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/snapshot/TestSnapshotDiffManager.java
@@ -21,12 +21,10 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import org.apache.commons.io.FileUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.hadoop.hdds.StringUtils;
 import org.apache.hadoop.hdds.client.ECReplicationConfig;
 import org.apache.hadoop.hdds.conf.OzoneConfiguration;
-import org.apache.hadoop.hdds.conf.StorageUnit;
 import org.apache.hadoop.hdds.utils.IOUtils;
 import org.apache.hadoop.hdds.utils.db.CodecRegistry;
 import org.apache.hadoop.hdds.utils.db.RDBStore;
@@ -35,7 +33,6 @@
 import org.apache.hadoop.hdds.utils.db.managed.ManagedColumnFamilyOptions;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedDBOptions;
 import org.apache.hadoop.hdds.utils.db.managed.ManagedRocksDB;
-import org.apache.hadoop.hdds.utils.db.managed.ManagedSSTDumpTool;
 import org.apache.hadoop.hdfs.DFSUtilClient;
 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport;
 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport.DiffReportEntry;
@@ -67,10 +64,9 @@
 import org.apache.ozone.rocksdiff.DifferSnapshotInfo;
 import org.apache.ozone.rocksdiff.RocksDBCheckpointDiffer;
 import org.apache.ozone.rocksdiff.RocksDiffUtils;
-import org.apache.ozone.test.tag.Unhealthy;
 import org.apache.ratis.util.ExitUtils;
-import org.awaitility.Awaitility;
 import javax.annotation.Nonnull;
+import org.awaitility.Awaitility;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
@@ -83,6 +79,7 @@
 import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.MockedConstruction;
 import org.mockito.MockedStatic;
@@ -136,10 +133,6 @@
 import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_FORCE_FULL_DIFF_DEFAULT;
 import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB;
 import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT;
-import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE;
-import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE_DEFAULT;
-import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE;
-import static org.apache.hadoop.ozone.om.OMConfigKeys.OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE_DEFAULT;
 import static org.apache.hadoop.ozone.om.OmSnapshotManager.DELIMITER;
 import static org.apache.hadoop.ozone.om.OmSnapshotManager.SNAP_DIFF_JOB_TABLE_NAME;
 import static org.apache.hadoop.ozone.om.OmSnapshotManager.SNAP_DIFF_REPORT_TABLE_NAME;
@@ -162,19 +155,19 @@
 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.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.ArgumentMatchers.anyMap;
-import static org.mockito.ArgumentMatchers.anySet;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.anyList;
+import static org.mockito.Mockito.anyMap;
+import static org.mockito.Mockito.anySet;
+import static org.mockito.Mockito.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
@@ -336,15 +329,6 @@ public void init() throws RocksDBException, IOException, ExecutionException {
         .getInt(OZONE_OM_SNAPSHOT_DIFF_THREAD_POOL_SIZE,
             OZONE_OM_SNAPSHOT_DIFF_THREAD_POOL_SIZE_DEFAULT))
         .thenReturn(OZONE_OM_SNAPSHOT_DIFF_THREAD_POOL_SIZE_DEFAULT);
-    when(configuration
-        .getInt(OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE,
-            OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE_DEFAULT))
-        .thenReturn(OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_POOL_SIZE_DEFAULT);
-    when(configuration
-        .getStorageSize(OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE,
-            OZONE_OM_SNAPSHOT_SST_DUMPTOOL_EXECUTOR_BUFFER_SIZE_DEFAULT,
-            StorageUnit.BYTES))
-        .thenReturn(FileUtils.ONE_KB_BI.doubleValue());
     when(configuration.getBoolean(OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB,
         OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT))
         .thenReturn(OZONE_OM_SNAPSHOT_LOAD_NATIVE_LIB_DEFAULT);
@@ -376,6 +360,7 @@ public void init() throws RocksDBException, IOException, ExecutionException {
     when(ozoneManager.getMetadataManager()).thenReturn(omMetadataManager);
 
     omSnapshotManager = mock(OmSnapshotManager.class);
+    when(ozoneManager.getOmSnapshotManager()).thenReturn(omSnapshotManager);
     when(omSnapshotManager.isSnapshotStatus(any(), any())).thenReturn(true);
     SnapshotCache snapshotCache = new SnapshotCache(mockCacheLoader(), 10, omMetrics, 0);
 
@@ -388,6 +373,7 @@ public void init() throws RocksDBException, IOException, ExecutionException {
     when(ozoneManager.getOmSnapshotManager()).thenReturn(omSnapshotManager);
     snapshotDiffManager = new SnapshotDiffManager(db, differ, ozoneManager,
         snapDiffJobTable, snapDiffReportTable, columnFamilyOptions, codecRegistry);
+    when(omSnapshotManager.getDiffCleanupServiceInterval()).thenReturn(0L);
   }
 
   private CacheLoader<UUID, OmSnapshot> mockCacheLoader() {
@@ -669,15 +655,11 @@ public void testObjectIdMapWithTombstoneEntries(boolean nativeLibraryLoaded,
     try (MockedConstruction<SstFileSetReader> mockedSSTFileReader =
              Mockito.mockConstruction(SstFileSetReader.class,
                  (mock, context) -> {
-                   when(mock.getKeyStreamWithTombstone(any(), any(), any()))
+                   when(mock.getKeyStreamWithTombstone(Matchers.any(), Matchers.any()))
                        .thenReturn(keysIncludingTombstones.stream());
                    when(mock.getKeyStream(any(), any()))
                        .thenReturn(keysExcludingTombstones.stream());
                  });
-         MockedConstruction<ManagedSSTDumpTool> mockedSSTDumpTool =
-             Mockito.mockConstruction(ManagedSSTDumpTool.class,
-                 (mock, context) -> {
-                 })
     ) {
       Map<String, WithParentObjectId> toSnapshotTableMap =
           IntStream.concat(IntStream.range(0, 25), IntStream.range(50, 100))
@@ -1583,7 +1565,6 @@ public void testGetSnapshotDiffReportHappyCase() throws Exception {
    * Tests that only QUEUED jobs are submitted to the executor and rest are
    * short-circuited based on previous one.
    */
-  @Unhealthy
   @Test
   public void testGetSnapshotDiffReportJob() throws Exception {
     for (int i = 0; i < jobStatuses.size(); i++) {
diff --git a/pom.xml b/pom.xml
index dd6dd7c75827..4c3483c9f54b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -305,11 +305,6 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xs
     <aspectj-plugin.version>1.14.0</aspectj-plugin.version>
     <restrict-imports.enforcer.version>2.0.0</restrict-imports.enforcer.version>
     <awaitility.version>4.2.0</awaitility.version>
-    <bzip2.version>1.0.8</bzip2.version>
-    <zlib.version>1.2.13</zlib.version>
-    <lz4.version>1.9.3</lz4.version>
-    <snappy.version>1.1.8</snappy.version>
-    <zstd.version>1.4.9</zstd.version>
     <jgrapht.version>1.4.0</jgrapht.version>
 
     <spring.version>5.3.34</spring.version>
@@ -317,12 +312,13 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xs
 
     <vault.driver.version>5.1.0</vault.driver.version>
     <native.lib.tmp.dir></native.lib.tmp.dir>
+    <properties.maven.plugin.version>1.2.1</properties.maven.plugin.version>
+    <maven.core.version>3.9.6</maven.core.version>
     <snappy-java.version>1.1.10.5</snappy-java.version>
     <hadoop-shaded-guava.version>1.2.0</hadoop-shaded-guava.version>
     <com.nimbusds.nimbus-jose-jwt.version>9.37.2</com.nimbusds.nimbus-jose-jwt.version>
   </properties>
 
-
   <dependencyManagement>
     <dependencies>
       <dependency>
@@ -2118,6 +2114,18 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xs
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>properties-maven-plugin</artifactId>
+        <version>${properties.maven.plugin.version}</version>
+        <dependencies>
+          <dependency>
+            <groupId>org.apache.maven</groupId>
+            <artifactId>maven-core</artifactId>
+            <version>${maven.core.version}</version>
+          </dependency>
+        </dependencies>
+      </plugin>
     </plugins>
   </build>
 

From 900bd4c145121eb1558883f01f9fd30d5fbbc615 Mon Sep 17 00:00:00 2001
From: Sarveksha Yeshavantha Raju
 <79865743+sarvekshayr@users.noreply.github.com>
Date: Tue, 27 Feb 2024 20:03:44 +0800
Subject: [PATCH 3/9] HDDS-815. Rename HDDS config keys prefixed with dfs.
 (#6274)

(cherry picked from commit 7939faf7d6c904bf1e4ad32baa5d6d0c1de19003)
---
 .../hadoop/hdds/conf/OzoneConfiguration.java  | 63 +++++++++++++++-
 .../apache/hadoop/hdds/scm/ScmConfigKeys.java | 38 +++++-----
 .../apache/hadoop/ozone/OzoneConfigKeys.java  | 22 +++---
 .../src/main/resources/ozone-default.xml      | 71 ++++++++++---------
 .../feature/Streaming-Write-Pipeline.md       |  4 +-
 .../runConfigurations/Datanode2-ha.xml        |  2 +-
 .../intellij/runConfigurations/Datanode2.xml  |  2 +-
 .../runConfigurations/Datanode3-ha.xml        |  2 +-
 .../intellij/runConfigurations/Datanode3.xml  |  2 +-
 .../src/main/compose/ozone-ha/docker-config   |  2 +-
 .../dist/src/main/compose/ozone/docker-config |  2 +-
 .../main/compose/ozonesecure-ha/docker-config |  2 +-
 .../main/compose/ozonesecure/docker-config    |  2 +-
 .../src/test/resources/ozone-site.xml         |  5 +-
 14 files changed, 143 insertions(+), 76 deletions(-)

diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java
index 10c2189f5649..85a1f74e56e4 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java
@@ -46,6 +46,7 @@
 import org.apache.hadoop.hdds.utils.LegacyHadoopConfigurationSource;
 
 import com.google.common.base.Preconditions;
+import org.apache.hadoop.ozone.OzoneConfigKeys;
 import org.apache.ratis.server.RaftServerConfigKeys;
 
 import static java.util.Collections.unmodifiableSortedSet;
@@ -332,7 +333,67 @@ private static void addDeprecatedKeys() {
         new DeprecationDelta("ozone.scm.chunk.layout",
             ScmConfigKeys.OZONE_SCM_CONTAINER_LAYOUT_KEY),
         new DeprecationDelta("hdds.datanode.replication.work.dir",
-            OZONE_CONTAINER_COPY_WORKDIR)
+            OZONE_CONTAINER_COPY_WORKDIR),
+        new DeprecationDelta("dfs.container.chunk.write.sync",
+            OzoneConfigKeys.DFS_CONTAINER_CHUNK_WRITE_SYNC_KEY),
+        new DeprecationDelta("dfs.container.ipc",
+            OzoneConfigKeys.DFS_CONTAINER_IPC_PORT),
+        new DeprecationDelta("dfs.container.ipc.random.port",
+            OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT),
+        new DeprecationDelta("dfs.container.ratis.admin.port",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_ADMIN_PORT),
+        new DeprecationDelta("dfs.container.ratis.datanode.storage.dir",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR),
+        new DeprecationDelta("dfs.container.ratis.datastream.enabled",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED),
+        new DeprecationDelta("dfs.container.ratis.datastream.port",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_PORT),
+        new DeprecationDelta("dfs.container.ratis.datastream.random.port",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT),
+        new DeprecationDelta("dfs.container.ratis.enabled",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY),
+        new DeprecationDelta("dfs.container.ratis.ipc",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT),
+        new DeprecationDelta("dfs.container.ratis.ipc.random.port",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT),
+        new DeprecationDelta("dfs.container.ratis.leader.pending.bytes.limit",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT),
+        new DeprecationDelta("dfs.container.ratis.log.appender.queue.byte-limit",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT),
+        new DeprecationDelta("dfs.container.ratis.log.appender.queue.num-elements",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS),
+        new DeprecationDelta("dfs.container.ratis.log.purge.gap",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP),
+        new DeprecationDelta("dfs.container.ratis.log.queue.byte-limit",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT),
+        new DeprecationDelta("dfs.container.ratis.log.queue.num-elements",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS),
+        new DeprecationDelta("dfs.container.ratis.num.container.op.executors",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY),
+        new DeprecationDelta("dfs.container.ratis.num.write.chunk.threads.per.volume",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME),
+        new DeprecationDelta("dfs.container.ratis.replication.level",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY),
+        new DeprecationDelta("dfs.container.ratis.rpc.type",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY),
+        new DeprecationDelta("dfs.container.ratis.segment.preallocated.size",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY),
+        new DeprecationDelta("dfs.container.ratis.segment.size",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY),
+        new DeprecationDelta("dfs.container.ratis.server.port",
+            OzoneConfigKeys.DFS_CONTAINER_RATIS_SERVER_PORT),
+        new DeprecationDelta("dfs.container.ratis.statemachinedata.sync.retries",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES),
+        new DeprecationDelta("dfs.container.ratis.statemachinedata.sync.timeout",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT),
+        new DeprecationDelta("dfs.container.ratis.statemachine.max.pending.apply-transactions",
+            ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS),
+        new DeprecationDelta("dfs.ratis.leader.election.minimum.timeout.duration",
+            ScmConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY),
+        new DeprecationDelta("dfs.ratis.server.retry-cache.timeout.duration",
+            ScmConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY),
+        new DeprecationDelta("dfs.ratis.snapshot.threshold",
+            ScmConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY)
     });
   }
 }
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java
index 007dc3dfaef8..94b58890efdc 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java
@@ -42,93 +42,93 @@ public final class ScmConfigKeys {
       "ozone.scm.db.dirs.permissions";
 
   public static final String DFS_CONTAINER_RATIS_ENABLED_KEY
-      = "dfs.container.ratis.enabled";
+      = "hdds.container.ratis.enabled";
   public static final boolean DFS_CONTAINER_RATIS_ENABLED_DEFAULT
       = false;
   public static final String DFS_CONTAINER_RATIS_RPC_TYPE_KEY
-      = "dfs.container.ratis.rpc.type";
+      = "hdds.container.ratis.rpc.type";
   public static final String DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT
       = "GRPC";
   public static final String
       DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME
-      = "dfs.container.ratis.num.write.chunk.threads.per.volume";
+      = "hdds.container.ratis.num.write.chunk.threads.per.volume";
   public static final int
       DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT
       = 10;
   public static final String DFS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY
-      = "dfs.container.ratis.replication.level";
+      = "hdds.container.ratis.replication.level";
   public static final ReplicationLevel
       DFS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT = ReplicationLevel.MAJORITY;
   public static final String DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY
-      = "dfs.container.ratis.num.container.op.executors";
+      = "hdds.container.ratis.num.container.op.executors";
   public static final int DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT
       = 10;
   public static final String DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY =
-      "dfs.container.ratis.segment.size";
+      "hdds.container.ratis.segment.size";
   public static final String DFS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT =
       "64MB";
   public static final String DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY =
-      "dfs.container.ratis.segment.preallocated.size";
+      "hdds.container.ratis.segment.preallocated.size";
   public static final String
       DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT = "4MB";
   public static final String
       DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT =
-      "dfs.container.ratis.statemachinedata.sync.timeout";
+      "hdds.container.ratis.statemachinedata.sync.timeout";
   public static final TimeDuration
       DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT =
       TimeDuration.valueOf(10, TimeUnit.SECONDS);
   public static final String
       DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES =
-      "dfs.container.ratis.statemachinedata.sync.retries";
+      "hdds.container.ratis.statemachinedata.sync.retries";
   public static final String
       DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS =
-      "dfs.container.ratis.statemachine.max.pending.apply-transactions";
+      "hdds.container.ratis.statemachine.max.pending.apply-transactions";
   // The default value of maximum number of pending state machine apply
   // transactions is kept same as default snapshot threshold.
   public static final int
       DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS_DEFAULT =
       100000;
   public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS =
-      "dfs.container.ratis.log.queue.num-elements";
+      "hdds.container.ratis.log.queue.num-elements";
   public static final int DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT =
       1024;
   public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT =
-      "dfs.container.ratis.log.queue.byte-limit";
+      "hdds.container.ratis.log.queue.byte-limit";
   public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT =
       "4GB";
   public static final String
       DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS =
-      "dfs.container.ratis.log.appender.queue.num-elements";
+      "hdds.container.ratis.log.appender.queue.num-elements";
   public static final int
       DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT = 1;
   public static final String DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT =
-      "dfs.container.ratis.log.appender.queue.byte-limit";
+      "hdds.container.ratis.log.appender.queue.byte-limit";
   public static final String
       DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT = "32MB";
   public static final String DFS_CONTAINER_RATIS_LOG_PURGE_GAP =
-      "dfs.container.ratis.log.purge.gap";
+      "hdds.container.ratis.log.purge.gap";
   // TODO: Set to 1024 once RATIS issue around purge is fixed.
   public static final int DFS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT =
       1000000;
   public static final String DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT =
-      "dfs.container.ratis.leader.pending.bytes.limit";
+      "hdds.container.ratis.leader.pending.bytes.limit";
   public static final String
       DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT = "1GB";
 
   public static final String DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY =
-      "dfs.ratis.server.retry-cache.timeout.duration";
+      "hdds.ratis.server.retry-cache.timeout.duration";
   public static final TimeDuration
       DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT =
       TimeDuration.valueOf(600000, TimeUnit.MILLISECONDS);
   public static final String
       DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY =
-      "dfs.ratis.leader.election.minimum.timeout.duration";
+      "hdds.ratis.leader.election.minimum.timeout.duration";
   public static final TimeDuration
       DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT =
       TimeDuration.valueOf(5, TimeUnit.SECONDS);
 
   public static final String DFS_RATIS_SNAPSHOT_THRESHOLD_KEY =
-      "dfs.ratis.snapshot.threshold";
+      "hdds.ratis.snapshot.threshold";
   public static final long DFS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT = 100000;
 
   // TODO : this is copied from OzoneConsts, may need to move to a better place
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java
index 21c89cc3c8d4..293401f4c275 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java
@@ -37,7 +37,7 @@
 @InterfaceStability.Unstable
 public final class OzoneConfigKeys {
   public static final String DFS_CONTAINER_IPC_PORT =
-      "dfs.container.ipc";
+      "hdds.container.ipc.port";
   public static final int DFS_CONTAINER_IPC_PORT_DEFAULT = 9859;
 
   public static final String OZONE_METADATA_DIRS = "ozone.metadata.dirs";
@@ -60,47 +60,47 @@ public final class OzoneConfigKeys {
    * as {@link #DFS_CONTAINER_IPC_PORT_DEFAULT}.
    */
   public static final String DFS_CONTAINER_IPC_RANDOM_PORT =
-      "dfs.container.ipc.random.port";
+      "hdds.container.ipc.random.port";
   public static final boolean DFS_CONTAINER_IPC_RANDOM_PORT_DEFAULT =
       false;
 
   public static final String DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT =
-      "dfs.container.ratis.datastream.random.port";
+      "hdds.container.ratis.datastream.random.port";
   public static final boolean
       DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT_DEFAULT =
       false;
 
   public static final String DFS_CONTAINER_CHUNK_WRITE_SYNC_KEY =
-      "dfs.container.chunk.write.sync";
+      "hdds.container.chunk.write.sync";
   public static final boolean DFS_CONTAINER_CHUNK_WRITE_SYNC_DEFAULT = false;
   /**
    * Ratis Port where containers listen to.
    */
   public static final String DFS_CONTAINER_RATIS_IPC_PORT =
-      "dfs.container.ratis.ipc";
+      "hdds.container.ratis.ipc.port";
   public static final int DFS_CONTAINER_RATIS_IPC_PORT_DEFAULT = 9858;
   /**
    * Ratis Port where containers listen to admin requests.
    */
   public static final String DFS_CONTAINER_RATIS_ADMIN_PORT =
-      "dfs.container.ratis.admin.port";
+      "hdds.container.ratis.admin.port";
   public static final int DFS_CONTAINER_RATIS_ADMIN_PORT_DEFAULT = 9857;
   /**
    * Ratis Port where containers listen to server-to-server requests.
    */
   public static final String DFS_CONTAINER_RATIS_SERVER_PORT =
-      "dfs.container.ratis.server.port";
+      "hdds.container.ratis.server.port";
   public static final int DFS_CONTAINER_RATIS_SERVER_PORT_DEFAULT = 9856;
 
   /**
    * Ratis Port where containers listen to datastream requests.
    */
   public static final String DFS_CONTAINER_RATIS_DATASTREAM_ENABLED
-      = "dfs.container.ratis.datastream.enabled";
+      = "hdds.container.ratis.datastream.enabled";
   public static final boolean DFS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT
       = false;
   public static final String DFS_CONTAINER_RATIS_DATASTREAM_PORT
-      = "dfs.container.ratis.datastream.port";
+      = "hdds.container.ratis.datastream.port";
   public static final int DFS_CONTAINER_RATIS_DATASTREAM_PORT_DEFAULT
       = 9855;
 
@@ -134,7 +134,7 @@ public final class OzoneConfigKeys {
    * a mini cluster is able to launch multiple containers on a node.
    */
   public static final String DFS_CONTAINER_RATIS_IPC_RANDOM_PORT =
-      "dfs.container.ratis.ipc.random.port";
+      "hdds.container.ratis.ipc.random.port";
   public static final boolean DFS_CONTAINER_RATIS_IPC_RANDOM_PORT_DEFAULT =
       false;
   public static final String OZONE_TRACE_ENABLED_KEY =
@@ -371,7 +371,7 @@ public final class OzoneConfigKeys {
       ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT;
 
   public static final String DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR =
-      "dfs.container.ratis.datanode.storage.dir";
+      "hdds.container.ratis.datanode.storage.dir";
 
   public static final String DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY =
       ScmConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY;
diff --git a/hadoop-hdds/common/src/main/resources/ozone-default.xml b/hadoop-hdds/common/src/main/resources/ozone-default.xml
index e9b74177e1c9..4cc32eb336c3 100644
--- a/hadoop-hdds/common/src/main/resources/ozone-default.xml
+++ b/hadoop-hdds/common/src/main/resources/ozone-default.xml
@@ -46,26 +46,26 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ipc</name>
+    <name>hdds.container.ipc.port</name>
     <value>9859</value>
     <tag>OZONE, CONTAINER, MANAGEMENT</tag>
     <description>The ipc port number of container.</description>
   </property>
 
   <property>
-    <name>dfs.container.ratis.datastream.enabled</name>
+    <name>hdds.container.ratis.datastream.enabled</name>
     <value>false</value>
     <tag>OZONE, CONTAINER, RATIS, DATASTREAM</tag>
     <description>It specifies whether to enable data stream of container.</description>
   </property>
   <property>
-    <name>dfs.container.ratis.datastream.port</name>
+    <name>hdds.container.ratis.datastream.port</name>
     <value>9855</value>
     <tag>OZONE, CONTAINER, RATIS, DATASTREAM</tag>
     <description>The datastream port number of container.</description>
   </property>
   <property>
-    <name>dfs.container.ratis.datastream.random.port</name>
+    <name>hdds.container.ratis.datastream.random.port</name>
     <value>false</value>
     <tag>OZONE, CONTAINER, RATIS, DATASTREAM</tag>
     <description>Allocates a random free port for ozone container datastream.
@@ -73,7 +73,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ipc.random.port</name>
+    <name>hdds.container.ipc.random.port</name>
     <value>false</value>
     <tag>OZONE, DEBUG, CONTAINER</tag>
     <description>Allocates a random free port for ozone container. This is used
@@ -82,7 +82,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.chunk.write.sync</name>
+    <name>hdds.container.chunk.write.sync</name>
     <value>false</value>
     <tag>OZONE, CONTAINER, MANAGEMENT</tag>
     <description>Determines whether the chunk writes in the container happen as
@@ -90,19 +90,19 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.statemachinedata.sync.timeout</name>
+    <name>hdds.container.ratis.statemachinedata.sync.timeout</name>
     <value>10s</value>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Timeout for StateMachine data writes by Ratis.
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.statemachinedata.sync.retries</name>
+    <name>hdds.container.ratis.statemachinedata.sync.retries</name>
     <value/>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Number of times the WriteStateMachineData op will be tried
       before failing. If the value is not configured, it will default
-      to (hdds.ratis.rpc.slowness.timeout / dfs.container.ratis.statemachinedata.sync.timeout),
+      to (hdds.ratis.rpc.slowness.timeout / hdds.container.ratis.statemachinedata.sync.timeout),
       which means that the WriteStatMachineData will be retried for every sync timeout until
       the configured slowness timeout is hit, after which the StateMachine will close down the pipeline.
 
@@ -112,21 +112,22 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.log.queue.num-elements</name>
+    <name>hdds.container.ratis.log.queue.num-elements</name>
     <value>1024</value>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Limit for the number of operations in Ratis Log Worker.
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.log.queue.byte-limit</name>
+    <name>hdds.container.ratis.log.queue.byte-limit</name>
     <value>4GB</value>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Byte limit for Ratis Log Worker queue.
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.log.appender.queue.num-elements</name>
+    <name>hdds.container.ratis.log.appender.queue.num-elements
+</name>
     <value>1</value>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Limit for number of append entries in ratis leader's
@@ -134,14 +135,16 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.log.appender.queue.byte-limit</name>
+    <name>hdds.container.ratis.log.appender.queue.byte-limit
+</name>
     <value>32MB</value>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Byte limit for ratis leader's log appender queue.
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.log.purge.gap</name>
+    <name>hdds.container.ratis.log.purge.gap
+</name>
     <value>1000000</value>
     <tag>OZONE, DEBUG, CONTAINER, RATIS</tag>
     <description>Purge gap between the last purged commit index
@@ -149,7 +152,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.datanode.storage.dir</name>
+    <name>hdds.container.ratis.datanode.storage.dir</name>
     <value/>
     <tag>OZONE, CONTAINER, STORAGE, MANAGEMENT, RATIS</tag>
     <description>This directory is used for storing Ratis metadata like logs. If
@@ -223,7 +226,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.enabled</name>
+    <name>hdds.container.ratis.enabled</name>
     <value>false</value>
     <tag>OZONE, MANAGEMENT, PIPELINE, RATIS</tag>
     <description>Ozone supports different kinds of replication pipelines. Ratis
@@ -232,25 +235,26 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.ipc</name>
+    <name>hdds.container.ratis.ipc.port</name>
     <value>9858</value>
     <tag>OZONE, CONTAINER, PIPELINE, RATIS</tag>
     <description>The ipc port number of container for clients.</description>
   </property>
   <property>
-    <name>dfs.container.ratis.admin.port</name>
+    <name>hdds.container.ratis.admin.port</name>
     <value>9857</value>
     <tag>OZONE, CONTAINER, PIPELINE, RATIS, MANAGEMENT</tag>
     <description>The ipc port number of container for admin requests.</description>
   </property>
   <property>
-    <name>dfs.container.ratis.server.port</name>
+    <name>hdds.container.ratis.server.port</name>
     <value>9856</value>
     <tag>OZONE, CONTAINER, PIPELINE, RATIS, MANAGEMENT</tag>
     <description>The ipc port number of container for server-server communication.</description>
   </property>
   <property>
-    <name>dfs.container.ratis.ipc.random.port</name>
+    <name>hdds.container.ratis.ipc.random.port
+</name>
     <value>false</value>
     <tag>OZONE,DEBUG</tag>
     <description>Allocates a random free port for ozone ratis port for the
@@ -259,7 +263,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.rpc.type</name>
+    <name>hdds.container.ratis.rpc.type</name>
     <value>GRPC</value>
     <tag>OZONE, RATIS, MANAGEMENT</tag>
     <description>Ratis supports different kinds of transports like netty, GRPC,
@@ -268,7 +272,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.ratis.snapshot.threshold</name>
+    <name>hdds.ratis.snapshot.threshold</name>
     <value>10000</value>
     <tag>OZONE, RATIS</tag>
     <description>Number of transactions after which a ratis snapshot should be
@@ -276,16 +280,16 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.statemachine.max.pending.apply-transactions</name>
+    <name>hdds.container.ratis.statemachine.max.pending.apply-transactions</name>
     <value>10000</value>
     <tag>OZONE, RATIS</tag>
     <description>Maximum number of pending apply transactions in a data
       pipeline. The default value is kept same as default snapshot threshold
-      dfs.ratis.snapshot.threshold.
+      hdds.ratis.snapshot.threshold.
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.num.write.chunk.threads.per.volume</name>
+    <name>hdds.container.ratis.num.write.chunk.threads.per.volume</name>
     <value>10</value>
     <tag>OZONE, RATIS, PERFORMANCE</tag>
     <description>Maximum number of threads in the thread pool that Datanode
@@ -295,7 +299,8 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.leader.pending.bytes.limit</name>
+    <name>hdds.container.ratis.leader.pending.bytes.limit
+</name>
     <value>1GB</value>
     <tag>OZONE, RATIS, PERFORMANCE</tag>
     <description>Limit on the total bytes of pending requests after which
@@ -303,7 +308,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.replication.level</name>
+    <name>hdds.container.ratis.replication.level</name>
     <value>MAJORITY</value>
     <tag>OZONE, RATIS</tag>
     <description>Replication level to be used by datanode for submitting a
@@ -312,7 +317,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.num.container.op.executors</name>
+    <name>hdds.container.ratis.num.container.op.executors</name>
     <value>10</value>
     <tag>OZONE, RATIS, PERFORMANCE</tag>
     <description>Number of executors that will be used by Ratis to execute
@@ -320,7 +325,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.segment.size</name>
+    <name>hdds.container.ratis.segment.size</name>
     <value>64MB</value>
     <tag>OZONE, RATIS, PERFORMANCE</tag>
     <description>The size of the raft segment file used
@@ -328,7 +333,7 @@
     </description>
   </property>
   <property>
-    <name>dfs.container.ratis.segment.preallocated.size</name>
+    <name>hdds.container.ratis.segment.preallocated.size</name>
     <value>4MB</value>
     <tag>OZONE, RATIS, PERFORMANCE</tag>
     <description>The pre-allocated file size for raft segment used
@@ -336,13 +341,13 @@
     </description>
   </property>
   <property>
-    <name>dfs.ratis.server.retry-cache.timeout.duration</name>
+    <name>hdds.ratis.server.retry-cache.timeout.duration</name>
     <value>600000ms</value>
     <tag>OZONE, RATIS, MANAGEMENT</tag>
     <description>Retry Cache entry timeout for ratis server.</description>
   </property>
   <property>
-    <name>dfs.ratis.leader.election.minimum.timeout.duration</name>
+    <name>hdds.ratis.leader.election.minimum.timeout.duration</name>
     <value>5s</value>
     <tag>OZONE, RATIS, MANAGEMENT</tag>
     <description>The minimum timeout duration for ratis leader election.
@@ -707,7 +712,7 @@
 
       For production clusters or any time you care about performance, it is
       recommended that ozone.om.db.dirs, ozone.scm.db.dirs and
-      dfs.container.ratis.datanode.storage.dir be configured separately.
+      hdds.container.ratis.datanode.storage.dir be configured separately.
     </description>
   </property>
   <property>
diff --git a/hadoop-hdds/docs/content/feature/Streaming-Write-Pipeline.md b/hadoop-hdds/docs/content/feature/Streaming-Write-Pipeline.md
index 5f55afebc3c8..e48a95c8bb9c 100644
--- a/hadoop-hdds/docs/content/feature/Streaming-Write-Pipeline.md
+++ b/hadoop-hdds/docs/content/feature/Streaming-Write-Pipeline.md
@@ -43,7 +43,7 @@ Set the following properties to the Ozone configuration file `ozone-site.xml`.
 - To enable the Streaming Write Pipeline feature, set the following property to true.
 ```XML
   <property>
-    <name>dfs.container.ratis.datastream.enabled</name>
+    <name>hdds.container.ratis.datastream.enabled</name>
     <value>false</value>
     <tag>OZONE, CONTAINER, RATIS, DATASTREAM</tag>
     <description>It specifies whether to enable data stream of container.</description>
@@ -52,7 +52,7 @@ Set the following properties to the Ozone configuration file `ozone-site.xml`.
 - Datanodes listen to the following port for the streaming traffic.
 ```XML
   <property>
-    <name>dfs.container.ratis.datastream.port</name>
+    <name>hdds.container.ratis.datastream.port</name>
     <value>9855</value>
     <tag>OZONE, CONTAINER, RATIS, DATASTREAM</tag>
     <description>The datastream port number of container.</description>
diff --git a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2-ha.xml b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2-ha.xml
index 171494aa5dbe..df9c4c0ab3e6 100644
--- a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2-ha.xml
+++ b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2-ha.xml
@@ -18,7 +18,7 @@
   <configuration default="false" name="Datanode2-ha" type="Application" factoryName="Application">
     <option name="MAIN_CLASS_NAME" value="org.apache.hadoop.ozone.HddsDatanodeService" />
     <module name="ozone-datanode" />
-    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site-ha.xml --set ozone.metadata.dirs=/tmp/datanode2 --set hdds.datanode.dir=/tmp/datanode2/storage --set hdds.datanode.http-address=127.0.0.1:10021 --set dfs.container.ratis.ipc=10022 --set dfs.container.ipc=10023 --set dfs.container.ratis.server.port=10024 --set dfs.container.ratis.admin.port=10025 --set hdds.datanode.replication.port=10026 --set dfs.container.ratis.datastream.port=10027 --set hdds.datanode.client.port=10028" />
+    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site-ha.xml --set ozone.metadata.dirs=/tmp/datanode2 --set hdds.datanode.dir=/tmp/datanode2/storage --set hdds.datanode.http-address=127.0.0.1:10021 --set hdds.container.ratis.ipc.port=10022 --set hdds.container.ipc.port=10023 --set hdds.container.ratis.server.port=10024 --set hdds.container.ratis.admin.port=10025 --set hdds.datanode.replication.port=10026 --set hdds.container.ratis.datastream.port=10027 --set hdds.datanode.client.port=10028" />
     <option name="VM_PARAMETERS" value="-Dlog4j.configuration=file:hadoop-ozone/dev-support/intellij/log4j.properties" />
     <extension name="coverage">
       <pattern>
diff --git a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2.xml b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2.xml
index 437757d649a4..f1f2f2f4f0cc 100644
--- a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2.xml
+++ b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode2.xml
@@ -18,7 +18,7 @@
   <configuration default="false" name="Datanode2" type="Application" factoryName="Application">
     <option name="MAIN_CLASS_NAME" value="org.apache.hadoop.ozone.HddsDatanodeService" />
     <module name="ozone-datanode" />
-    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site.xml --set ozone.metadata.dirs=/tmp/datanode2 --set hdds.datanode.dir=/tmp/datanode2/storage --set hdds.datanode.http-address=127.0.0.1:10021 --set dfs.container.ratis.ipc=10022 --set dfs.container.ipc=10023 --set dfs.container.ratis.server.port=10024 --set dfs.container.ratis.admin.port=10025 --set hdds.datanode.replication.port=10026 --set dfs.container.ratis.datastream.port=10027 --set hdds.datanode.client.port=10028" />
+    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site.xml --set ozone.metadata.dirs=/tmp/datanode2 --set hdds.datanode.dir=/tmp/datanode2/storage --set hdds.datanode.http-address=127.0.0.1:10021 --set hdds.container.ratis.ipc.port=10022 --set hdds.container.ipc.port=10023 --set hdds.container.ratis.server.port=10024 --set hdds.container.ratis.admin.port=10025 --set hdds.datanode.replication.port=10026 --set hdds.container.ratis.datastream.port=10027 --set hdds.datanode.client.port=10028" />
     <option name="VM_PARAMETERS" value="-Dlog4j.configuration=file:hadoop-ozone/dev-support/intellij/log4j.properties" />
     <extension name="coverage">
       <pattern>
diff --git a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3-ha.xml b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3-ha.xml
index 4a820682a0b0..5e4c7ffb946a 100644
--- a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3-ha.xml
+++ b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3-ha.xml
@@ -18,7 +18,7 @@
   <configuration default="false" name="Datanode3-ha" type="Application" factoryName="Application">
     <option name="MAIN_CLASS_NAME" value="org.apache.hadoop.ozone.HddsDatanodeService" />
     <module name="ozone-datanode" />
-    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site-ha.xml --set ozone.metadata.dirs=/tmp/datanode3 --set hdds.datanode.dir=/tmp/datanode3/storage --set hdds.datanode.http-address=127.0.0.1:10031 --set dfs.container.ratis.ipc=10032 --set dfs.container.ipc=10033 --set dfs.container.ratis.server.port=10034 --set dfs.container.ratis.admin.port=10035 --set hdds.datanode.replication.port=10036 --set dfs.container.ratis.datastream.port=10037 --set hdds.datanode.client.port=10038" />
+    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site-ha.xml --set ozone.metadata.dirs=/tmp/datanode3 --set hdds.datanode.dir=/tmp/datanode3/storage --set hdds.datanode.http-address=127.0.0.1:10031 --set hdds.container.ratis.ipc.port=10032 --set hdds.container.ipc.port=10033 --set hdds.container.ratis.server.port=10034 --set hdds.container.ratis.admin.port=10035 --set hdds.datanode.replication.port=10036 --set hdds.container.ratis.datastream.port=10037 --set hdds.datanode.client.port=10038" />
     <option name="VM_PARAMETERS" value="-Dlog4j.configuration=file:hadoop-ozone/dev-support/intellij/log4j.properties" />
     <extension name="coverage">
       <pattern>
diff --git a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3.xml b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3.xml
index 590251b0c596..1c9d946b81c4 100644
--- a/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3.xml
+++ b/hadoop-ozone/dev-support/intellij/runConfigurations/Datanode3.xml
@@ -18,7 +18,7 @@
   <configuration default="false" name="Datanode3" type="Application" factoryName="Application">
     <option name="MAIN_CLASS_NAME" value="org.apache.hadoop.ozone.HddsDatanodeService" />
     <module name="ozone-datanode" />
-    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site.xml --set ozone.metadata.dirs=/tmp/datanode3 --set hdds.datanode.dir=/tmp/datanode3/storage --set hdds.datanode.http-address=127.0.0.1:10031 --set dfs.container.ratis.ipc=10032 --set dfs.container.ipc=10033 --set dfs.container.ratis.server.port=10034 --set dfs.container.ratis.admin.port=10035 --set hdds.datanode.replication.port=10036 --set dfs.container.ratis.datastream.port=10037 --set hdds.datanode.client.port=10038" />
+    <option name="PROGRAM_PARAMETERS" value="-conf=hadoop-ozone/dev-support/intellij/ozone-site.xml --set ozone.metadata.dirs=/tmp/datanode3 --set hdds.datanode.dir=/tmp/datanode3/storage --set hdds.datanode.http-address=127.0.0.1:10031 --set hdds.container.ratis.ipc.port=10032 --set hdds.container.ipc.port=10033 --set hdds.container.ratis.server.port=10034 --set hdds.container.ratis.admin.port=10035 --set hdds.datanode.replication.port=10036 --set hdds.container.ratis.datastream.port=10037 --set hdds.datanode.client.port=10038" />
     <option name="VM_PARAMETERS" value="-Dlog4j.configuration=file:hadoop-ozone/dev-support/intellij/log4j.properties" />
     <extension name="coverage">
       <pattern>
diff --git a/hadoop-ozone/dist/src/main/compose/ozone-ha/docker-config b/hadoop-ozone/dist/src/main/compose/ozone-ha/docker-config
index bdd504d6e255..ab8485ef729e 100644
--- a/hadoop-ozone/dist/src/main/compose/ozone-ha/docker-config
+++ b/hadoop-ozone/dist/src/main/compose/ozone-ha/docker-config
@@ -49,7 +49,7 @@ OZONE-SITE.XML_ozone.recon.db.dir=/data/metadata/recon
 OZONE-SITE.XML_ozone.recon.address=recon:9891
 OZONE-SITE.XML_ozone.recon.http-address=0.0.0.0:9888
 OZONE-SITE.XML_ozone.recon.https-address=0.0.0.0:9889
-OZONE-SITE.XML_dfs.container.ratis.datastream.enabled=true
+OZONE-SITE.XML_hdds.container.ratis.datastream.enabled=true
 
 OZONE_CONF_DIR=/etc/hadoop
 OZONE_LOG_DIR=/var/log/hadoop
diff --git a/hadoop-ozone/dist/src/main/compose/ozone/docker-config b/hadoop-ozone/dist/src/main/compose/ozone/docker-config
index 729f036e15c3..83057f9d394e 100644
--- a/hadoop-ozone/dist/src/main/compose/ozone/docker-config
+++ b/hadoop-ozone/dist/src/main/compose/ozone/docker-config
@@ -52,7 +52,7 @@ OZONE-SITE.XML_hdds.scm.replication.under.replicated.interval=5s
 OZONE-SITE.XML_hdds.scm.replication.over.replicated.interval=5s
 OZONE-SITE.XML_hdds.scm.wait.time.after.safemode.exit=30s
 
-OZONE-SITE.XML_dfs.container.ratis.datastream.enabled=true
+OZONE-SITE.XML_hdds.container.ratis.datastream.enabled=true
 
 OZONE_CONF_DIR=/etc/hadoop
 OZONE_LOG_DIR=/var/log/hadoop
diff --git a/hadoop-ozone/dist/src/main/compose/ozonesecure-ha/docker-config b/hadoop-ozone/dist/src/main/compose/ozonesecure-ha/docker-config
index b9fc5344c722..c4bf86dd8efc 100644
--- a/hadoop-ozone/dist/src/main/compose/ozonesecure-ha/docker-config
+++ b/hadoop-ozone/dist/src/main/compose/ozonesecure-ha/docker-config
@@ -57,7 +57,7 @@ OZONE-SITE.XML_hdds.grpc.tls.enabled=true
 OZONE-SITE.XML_ozone.server.default.replication=3
 OZONE-SITE.XML_hdds.scmclient.max.retry.timeout=30s
 OZONE-SITE.XML_hdds.container.report.interval=60s
-OZONE-SITE.XML_dfs.container.ratis.datastream.enabled=true
+OZONE-SITE.XML_hdds.container.ratis.datastream.enabled=true
 
 OZONE-SITE.XML_ozone.recon.om.snapshot.task.interval.delay=1m
 OZONE-SITE.XML_ozone.recon.db.dir=/data/metadata/recon
diff --git a/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config b/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config
index f5c32ff3aa2c..0dd7e3c2e0c0 100644
--- a/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config
+++ b/hadoop-ozone/dist/src/main/compose/ozonesecure/docker-config
@@ -85,7 +85,7 @@ OZONE-SITE.XML_hdds.container.report.interval=60s
 OZONE-SITE.XML_ozone.scm.close.container.wait.duration=5s
 
 # Ratis streaming is disabled to ensure coverage for both cases
-OZONE-SITE.XML_dfs.container.ratis.datastream.enabled=false
+OZONE-SITE.XML_hdds.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
diff --git a/hadoop-ozone/integration-test/src/test/resources/ozone-site.xml b/hadoop-ozone/integration-test/src/test/resources/ozone-site.xml
index 4c415c0c7e0d..9687ed06ae44 100644
--- a/hadoop-ozone/integration-test/src/test/resources/ozone-site.xml
+++ b/hadoop-ozone/integration-test/src/test/resources/ozone-site.xml
@@ -37,7 +37,7 @@
   </property>
 
   <property>
-    <name>dfs.container.ratis.num.write.chunk.threads.per.volume</name>
+    <name>hdds.container.ratis.num.write.chunk.threads.per.volume</name>
     <value>4</value>
   </property>
 
@@ -52,7 +52,8 @@
   </property>
 
   <property>
-    <name>dfs.container.ratis.log.appender.queue.byte-limit</name>
+    <name>hdds.container.ratis.log.appender.queue.byte-limit
+</name>
     <value>8MB</value>
   </property>
   <property>

From ac37389a5db96ff6f0c43aa65f5d494bfa4bcce4 Mon Sep 17 00:00:00 2001
From: Sarveksha Yeshavantha Raju
 <79865743+sarvekshayr@users.noreply.github.com>
Date: Thu, 29 Feb 2024 00:40:30 +0800
Subject: [PATCH 4/9] HDDS-10331. Rename Java constants of ex-DFS config keys
 (#6290)

(cherry picked from commit 01f8d62fbee2be4c79c4b4d4bf759a81f5ea30bb)
---
 .../hadoop/hdds/scm/XceiverClientGrpc.java    |   4 +-
 .../hadoop/hdds/scm/XceiverClientRatis.java   |   4 +-
 .../hadoop/hdds/conf/OzoneConfiguration.java  |  60 +++---
 .../apache/hadoop/hdds/ratis/RatisHelper.java |   4 +-
 .../apache/hadoop/hdds/scm/ScmConfigKeys.java |  74 +++----
 .../apache/hadoop/ozone/OzoneConfigKeys.java  | 186 +++++++++---------
 .../transport/server/XceiverServerGrpc.java   |   8 +-
 .../server/ratis/ContainerStateMachine.java   |  12 +-
 .../server/ratis/XceiverServerRatis.java      | 108 +++++-----
 .../container/keyvalue/KeyValueHandler.java   |   4 +-
 .../keyvalue/impl/ChunkManagerFactory.java    |   4 +-
 .../container/common/ContainerTestUtils.java  |   2 +-
 .../ozone/container/common/SCMTestUtils.java  |   4 +-
 .../common/TestDatanodeStateMachine.java      |  12 +-
 .../TestDatanodeConfiguration.java            |   2 +-
 .../volume/TestPeriodicVolumeChecker.java     |   2 +-
 .../common/volume/TestVolumeSet.java          |   2 +-
 .../volume/TestVolumeSetDiskChecks.java       |   2 +-
 .../ozoneimpl/TestContainerReader.java        |   2 +-
 .../ozoneimpl/TestOzoneContainer.java         |   2 +-
 .../TestDatanodeUpgradeToSchemaV3.java        |   4 +-
 .../hadoop/hdds/utils/HddsServerUtil.java     |   6 +-
 .../ozone/container/common/TestEndPoint.java  |  18 +-
 .../scm/cli/ContainerOperationClient.java     |   4 +-
 .../hadoop/ozone/MiniOzoneChaosCluster.java   |   8 +-
 .../TestOzoneFileSystemWithStreaming.java     |   4 +-
 .../hdds/scm/TestRatisPipelineLeader.java     |   4 +-
 .../hadoop/ozone/MiniOzoneClusterImpl.java    |  24 +--
 .../apache/hadoop/ozone/RatisTestHelper.java  |   6 +-
 .../hadoop/ozone/TestMiniOzoneCluster.java    |  18 +-
 .../client/rpc/TestContainerStateMachine.java |   2 +-
 .../TestContainerStateMachineFailures.java    |  10 +-
 .../TestContainerStateMachineFlushDelay.java  |   2 +-
 .../rpc/TestContainerStateMachineStream.java  |   2 +-
 .../rpc/TestFailureHandlingByClient.java      |   2 +-
 ...TestFailureHandlingByClientFlushDelay.java |   2 +-
 .../TestMultiBlockWritesWithDnFailures.java   |   2 +-
 .../server/ratis/TestCSMMetrics.java          |   4 +-
 .../metrics/TestContainerMetrics.java         |   2 +-
 .../ozoneimpl/TestOzoneContainer.java         |   4 +-
 .../ozoneimpl/TestSecureOzoneContainer.java   |   4 +-
 .../container/server/TestContainerServer.java |   8 +-
 .../server/TestSecureContainerServer.java     |  10 +-
 .../ozone/dn/ratis/TestDnRatisLogParser.java  |   2 +-
 .../hadoop/ozone/shell/TestScmAdminHA.java    |   2 +-
 .../fs/ozone/BasicOzoneClientAdapterImpl.java |   4 +-
 .../BasicRootedOzoneClientAdapterImpl.java    |   4 +-
 .../ozone/s3/endpoint/ObjectEndpoint.java     |   8 +-
 .../s3/endpoint/TestPartUploadWithStream.java |   2 +-
 .../s3/endpoint/TestUploadWithStream.java     |   2 +-
 50 files changed, 336 insertions(+), 336 deletions(-)

diff --git a/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java b/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java
index 6e2e1522a705..e8bc12e64162 100644
--- a/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java
+++ b/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java
@@ -167,8 +167,8 @@ private synchronized void connectToDatanode(DatanodeDetails dn)
     // port.
     int port = dn.getPort(DatanodeDetails.Port.Name.STANDALONE).getValue();
     if (port == 0) {
-      port = config.getInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
-          OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+      port = config.getInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+          OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
     }
 
     // Add credential context to the client call
diff --git a/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientRatis.java b/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientRatis.java
index aff0aa966a79..58a2153352a4 100644
--- a/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientRatis.java
+++ b/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientRatis.java
@@ -83,8 +83,8 @@ public static XceiverClientRatis newXceiverClientRatis(
       org.apache.hadoop.hdds.scm.pipeline.Pipeline pipeline,
       ConfigurationSource ozoneConf, ClientTrustManager trustManager) {
     final String rpcType = ozoneConf
-        .get(ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
-            ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
+        .get(ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY,
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
     final RetryPolicy retryPolicy = RatisHelper.createRetryPolicy(ozoneConf);
     final GrpcTlsConfig tlsConfig = RatisHelper.createTlsClientConfig(new
         SecurityConfig(ozoneConf), trustManager);
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java
index 85a1f74e56e4..6a87c69b5351 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/conf/OzoneConfiguration.java
@@ -335,65 +335,65 @@ private static void addDeprecatedKeys() {
         new DeprecationDelta("hdds.datanode.replication.work.dir",
             OZONE_CONTAINER_COPY_WORKDIR),
         new DeprecationDelta("dfs.container.chunk.write.sync",
-            OzoneConfigKeys.DFS_CONTAINER_CHUNK_WRITE_SYNC_KEY),
+            OzoneConfigKeys.HDDS_CONTAINER_CHUNK_WRITE_SYNC_KEY),
         new DeprecationDelta("dfs.container.ipc",
-            OzoneConfigKeys.DFS_CONTAINER_IPC_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT),
         new DeprecationDelta("dfs.container.ipc.random.port",
-            OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT),
         new DeprecationDelta("dfs.container.ratis.admin.port",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_ADMIN_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_ADMIN_PORT),
         new DeprecationDelta("dfs.container.ratis.datanode.storage.dir",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR),
         new DeprecationDelta("dfs.container.ratis.datastream.enabled",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED),
         new DeprecationDelta("dfs.container.ratis.datastream.port",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_PORT),
         new DeprecationDelta("dfs.container.ratis.datastream.random.port",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT),
         new DeprecationDelta("dfs.container.ratis.enabled",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_KEY),
         new DeprecationDelta("dfs.container.ratis.ipc",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT),
         new DeprecationDelta("dfs.container.ratis.ipc.random.port",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT),
         new DeprecationDelta("dfs.container.ratis.leader.pending.bytes.limit",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT),
         new DeprecationDelta("dfs.container.ratis.log.appender.queue.byte-limit",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT),
         new DeprecationDelta("dfs.container.ratis.log.appender.queue.num-elements",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS),
         new DeprecationDelta("dfs.container.ratis.log.purge.gap",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_PURGE_GAP),
         new DeprecationDelta("dfs.container.ratis.log.queue.byte-limit",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT),
         new DeprecationDelta("dfs.container.ratis.log.queue.num-elements",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS),
         new DeprecationDelta("dfs.container.ratis.num.container.op.executors",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY),
         new DeprecationDelta("dfs.container.ratis.num.write.chunk.threads.per.volume",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME),
         new DeprecationDelta("dfs.container.ratis.replication.level",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY),
         new DeprecationDelta("dfs.container.ratis.rpc.type",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY),
         new DeprecationDelta("dfs.container.ratis.segment.preallocated.size",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY),
         new DeprecationDelta("dfs.container.ratis.segment.size",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY),
         new DeprecationDelta("dfs.container.ratis.server.port",
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_SERVER_PORT),
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_SERVER_PORT),
         new DeprecationDelta("dfs.container.ratis.statemachinedata.sync.retries",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES),
         new DeprecationDelta("dfs.container.ratis.statemachinedata.sync.timeout",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT),
         new DeprecationDelta("dfs.container.ratis.statemachine.max.pending.apply-transactions",
-            ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS),
+            ScmConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS),
         new DeprecationDelta("dfs.ratis.leader.election.minimum.timeout.duration",
-            ScmConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY),
+            ScmConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY),
         new DeprecationDelta("dfs.ratis.server.retry-cache.timeout.duration",
-            ScmConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY),
+            ScmConfigKeys.HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY),
         new DeprecationDelta("dfs.ratis.snapshot.threshold",
-            ScmConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY)
+            ScmConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY)
     });
   }
 }
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/ratis/RatisHelper.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/ratis/RatisHelper.java
index 4d172ef6ab97..0b79273e5118 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/ratis/RatisHelper.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/ratis/RatisHelper.java
@@ -228,8 +228,8 @@ public static RaftClient newRaftClient(RpcType rpcType, Pipeline pipeline,
 
   private static RpcType getRpcType(ConfigurationSource conf) {
     return SupportedRpcType.valueOfIgnoreCase(conf.get(
-        ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
-        ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT));
+        ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY,
+        ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_DEFAULT));
   }
 
   public static BiFunction<RaftPeer, GrpcTlsConfig, RaftClient> newRaftClient(
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java
index 94b58890efdc..52e2a26f6431 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/hdds/scm/ScmConfigKeys.java
@@ -41,95 +41,95 @@ public final class ScmConfigKeys {
   public static final String OZONE_SCM_DB_DIRS_PERMISSIONS =
       "ozone.scm.db.dirs.permissions";
 
-  public static final String DFS_CONTAINER_RATIS_ENABLED_KEY
+  public static final String HDDS_CONTAINER_RATIS_ENABLED_KEY
       = "hdds.container.ratis.enabled";
-  public static final boolean DFS_CONTAINER_RATIS_ENABLED_DEFAULT
+  public static final boolean HDDS_CONTAINER_RATIS_ENABLED_DEFAULT
       = false;
-  public static final String DFS_CONTAINER_RATIS_RPC_TYPE_KEY
+  public static final String HDDS_CONTAINER_RATIS_RPC_TYPE_KEY
       = "hdds.container.ratis.rpc.type";
-  public static final String DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT
+  public static final String HDDS_CONTAINER_RATIS_RPC_TYPE_DEFAULT
       = "GRPC";
   public static final String
-      DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME
+      HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME
       = "hdds.container.ratis.num.write.chunk.threads.per.volume";
   public static final int
-      DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT
+      HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT
       = 10;
-  public static final String DFS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY
+  public static final String HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY
       = "hdds.container.ratis.replication.level";
   public static final ReplicationLevel
-      DFS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT = ReplicationLevel.MAJORITY;
-  public static final String DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY
+      HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT = ReplicationLevel.MAJORITY;
+  public static final String HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY
       = "hdds.container.ratis.num.container.op.executors";
-  public static final int DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT
+  public static final int HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT
       = 10;
-  public static final String DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY =
+  public static final String HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY =
       "hdds.container.ratis.segment.size";
-  public static final String DFS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT =
+  public static final String HDDS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT =
       "64MB";
-  public static final String DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY =
+  public static final String HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY =
       "hdds.container.ratis.segment.preallocated.size";
   public static final String
-      DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT = "4MB";
+      HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT = "4MB";
   public static final String
-      DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT =
+      HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT =
       "hdds.container.ratis.statemachinedata.sync.timeout";
   public static final TimeDuration
-      DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT =
+      HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT =
       TimeDuration.valueOf(10, TimeUnit.SECONDS);
   public static final String
-      DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES =
+      HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES =
       "hdds.container.ratis.statemachinedata.sync.retries";
   public static final String
-      DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS =
+      HDDS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS =
       "hdds.container.ratis.statemachine.max.pending.apply-transactions";
   // The default value of maximum number of pending state machine apply
   // transactions is kept same as default snapshot threshold.
   public static final int
-      DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS_DEFAULT =
+      HDDS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS_DEFAULT =
       100000;
-  public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS =
+  public static final String HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS =
       "hdds.container.ratis.log.queue.num-elements";
-  public static final int DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT =
+  public static final int HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT =
       1024;
-  public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT =
+  public static final String HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT =
       "hdds.container.ratis.log.queue.byte-limit";
-  public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT =
+  public static final String HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT =
       "4GB";
   public static final String
-      DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS =
+      HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS =
       "hdds.container.ratis.log.appender.queue.num-elements";
   public static final int
-      DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT = 1;
-  public static final String DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT =
+      HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT = 1;
+  public static final String HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT =
       "hdds.container.ratis.log.appender.queue.byte-limit";
   public static final String
-      DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT = "32MB";
-  public static final String DFS_CONTAINER_RATIS_LOG_PURGE_GAP =
+      HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT = "32MB";
+  public static final String HDDS_CONTAINER_RATIS_LOG_PURGE_GAP =
       "hdds.container.ratis.log.purge.gap";
   // TODO: Set to 1024 once RATIS issue around purge is fixed.
-  public static final int DFS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT =
+  public static final int HDDS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT =
       1000000;
-  public static final String DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT =
+  public static final String HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT =
       "hdds.container.ratis.leader.pending.bytes.limit";
   public static final String
-      DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT = "1GB";
+      HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT = "1GB";
 
-  public static final String DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY =
+  public static final String HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY =
       "hdds.ratis.server.retry-cache.timeout.duration";
   public static final TimeDuration
-      DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT =
+      HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT =
       TimeDuration.valueOf(600000, TimeUnit.MILLISECONDS);
   public static final String
-      DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY =
+      HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY =
       "hdds.ratis.leader.election.minimum.timeout.duration";
   public static final TimeDuration
-      DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT =
+      HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT =
       TimeDuration.valueOf(5, TimeUnit.SECONDS);
 
-  public static final String DFS_RATIS_SNAPSHOT_THRESHOLD_KEY =
+  public static final String HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY =
       "hdds.ratis.snapshot.threshold";
-  public static final long DFS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT = 100000;
+  public static final long HDDS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT = 100000;
 
   // TODO : this is copied from OzoneConsts, may need to move to a better place
   public static final String OZONE_SCM_CHUNK_SIZE_KEY = "ozone.scm.chunk.size";
diff --git a/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java b/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java
index 293401f4c275..9508d9125311 100644
--- a/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java
+++ b/hadoop-hdds/common/src/main/java/org/apache/hadoop/ozone/OzoneConfigKeys.java
@@ -36,9 +36,9 @@
 @InterfaceAudience.Public
 @InterfaceStability.Unstable
 public final class OzoneConfigKeys {
-  public static final String DFS_CONTAINER_IPC_PORT =
+  public static final String HDDS_CONTAINER_IPC_PORT =
       "hdds.container.ipc.port";
-  public static final int DFS_CONTAINER_IPC_PORT_DEFAULT = 9859;
+  public static final int HDDS_CONTAINER_IPC_PORT_DEFAULT = 9859;
 
   public static final String OZONE_METADATA_DIRS = "ozone.metadata.dirs";
 
@@ -56,52 +56,52 @@ public final class OzoneConfigKeys {
    * so that a mini cluster is able to launch multiple containers on a node.
    *
    * When set to false (default), the container port will be specified as
-   * {@link #DFS_CONTAINER_IPC_PORT} and the default value will be specified
-   * as {@link #DFS_CONTAINER_IPC_PORT_DEFAULT}.
+   * {@link #HDDS_CONTAINER_IPC_PORT} and the default value will be specified
+   * as {@link #HDDS_CONTAINER_IPC_PORT_DEFAULT}.
    */
-  public static final String DFS_CONTAINER_IPC_RANDOM_PORT =
+  public static final String HDDS_CONTAINER_IPC_RANDOM_PORT =
       "hdds.container.ipc.random.port";
-  public static final boolean DFS_CONTAINER_IPC_RANDOM_PORT_DEFAULT =
+  public static final boolean HDDS_CONTAINER_IPC_RANDOM_PORT_DEFAULT =
       false;
 
-  public static final String DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT =
+  public static final String HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT =
       "hdds.container.ratis.datastream.random.port";
   public static final boolean
-      DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT_DEFAULT =
+      HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT_DEFAULT =
       false;
 
-  public static final String DFS_CONTAINER_CHUNK_WRITE_SYNC_KEY =
+  public static final String HDDS_CONTAINER_CHUNK_WRITE_SYNC_KEY =
       "hdds.container.chunk.write.sync";
-  public static final boolean DFS_CONTAINER_CHUNK_WRITE_SYNC_DEFAULT = false;
+  public static final boolean HDDS_CONTAINER_CHUNK_WRITE_SYNC_DEFAULT = false;
   /**
    * Ratis Port where containers listen to.
    */
-  public static final String DFS_CONTAINER_RATIS_IPC_PORT =
+  public static final String HDDS_CONTAINER_RATIS_IPC_PORT =
       "hdds.container.ratis.ipc.port";
-  public static final int DFS_CONTAINER_RATIS_IPC_PORT_DEFAULT = 9858;
+  public static final int HDDS_CONTAINER_RATIS_IPC_PORT_DEFAULT = 9858;
   /**
    * Ratis Port where containers listen to admin requests.
    */
-  public static final String DFS_CONTAINER_RATIS_ADMIN_PORT =
+  public static final String HDDS_CONTAINER_RATIS_ADMIN_PORT =
       "hdds.container.ratis.admin.port";
-  public static final int DFS_CONTAINER_RATIS_ADMIN_PORT_DEFAULT = 9857;
+  public static final int HDDS_CONTAINER_RATIS_ADMIN_PORT_DEFAULT = 9857;
   /**
    * Ratis Port where containers listen to server-to-server requests.
    */
-  public static final String DFS_CONTAINER_RATIS_SERVER_PORT =
+  public static final String HDDS_CONTAINER_RATIS_SERVER_PORT =
       "hdds.container.ratis.server.port";
-  public static final int DFS_CONTAINER_RATIS_SERVER_PORT_DEFAULT = 9856;
+  public static final int HDDS_CONTAINER_RATIS_SERVER_PORT_DEFAULT = 9856;
 
   /**
    * Ratis Port where containers listen to datastream requests.
    */
-  public static final String DFS_CONTAINER_RATIS_DATASTREAM_ENABLED
+  public static final String HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED
       = "hdds.container.ratis.datastream.enabled";
-  public static final boolean DFS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT
+  public static final boolean HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT
       = false;
-  public static final String DFS_CONTAINER_RATIS_DATASTREAM_PORT
+  public static final String HDDS_CONTAINER_RATIS_DATASTREAM_PORT
       = "hdds.container.ratis.datastream.port";
-  public static final int DFS_CONTAINER_RATIS_DATASTREAM_PORT_DEFAULT
+  public static final int HDDS_CONTAINER_RATIS_DATASTREAM_PORT_DEFAULT
       = 9855;
 
   /**
@@ -133,9 +133,9 @@ public final class OzoneConfigKeys {
    * When set to true, allocate a random free port for ozone container, so that
    * a mini cluster is able to launch multiple containers on a node.
    */
-  public static final String DFS_CONTAINER_RATIS_IPC_RANDOM_PORT =
+  public static final String HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT =
       "hdds.container.ratis.ipc.random.port";
-  public static final boolean DFS_CONTAINER_RATIS_IPC_RANDOM_PORT_DEFAULT =
+  public static final boolean HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT_DEFAULT =
       false;
   public static final String OZONE_TRACE_ENABLED_KEY =
       "ozone.trace.enabled";
@@ -328,97 +328,97 @@ public final class OzoneConfigKeys {
   public static final int
       OZONE_BLOCK_DELETING_CONTAINER_LIMIT_PER_INTERVAL_DEFAULT = 10;
 
-  public static final String DFS_CONTAINER_RATIS_ENABLED_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY;
-  public static final boolean DFS_CONTAINER_RATIS_ENABLED_DEFAULT
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_RPC_TYPE_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY;
-  public static final String DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_ENABLED_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_KEY;
+  public static final boolean HDDS_CONTAINER_RATIS_ENABLED_DEFAULT
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_RPC_TYPE_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY;
+  public static final String HDDS_CONTAINER_RATIS_RPC_TYPE_DEFAULT
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_DEFAULT;
   public static final String
-      DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME;
+      HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME;
   public static final int
-      DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT
+      HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT
       = ScmConfigKeys.
-      DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY;
+      HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_KEY;
   public static final ReplicationLevel
-      DFS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY;
-  public static final int DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY;
-  public static final String DFS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY
-      = ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY;
+      HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_REPLICATION_LEVEL_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY;
+  public static final int HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY;
+  public static final String HDDS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY
+      = ScmConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY;
   public static final String
-      DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT;
+      HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT;
 
   // config settings to enable stateMachineData write timeout
   public static final String
-      DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT;
+      HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT;
   public static final TimeDuration
-      DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT;
+      HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT;
 
-  public static final String DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR =
+  public static final String HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR =
       "hdds.container.ratis.datanode.storage.dir";
 
-  public static final String DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY =
-      ScmConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY;
+  public static final String HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY =
+      ScmConfigKeys.HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY;
   public static final TimeDuration
-      DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT =
-      ScmConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT;
+      HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT =
+      ScmConfigKeys.HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT;
   public static final String
-      DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES;
-  public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS;
-  public static final int DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT;
-  public static final String DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT;
+      HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES;
+  public static final String HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS;
+  public static final int HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT;
+  public static final String HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT;
   public static final String
-      DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS;
+      HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS;
   public static final int
-      DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT;
+      HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT;
   public static final String
-      DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_LOG_PURGE_GAP =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP;
-  public static final int DFS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT;
-  public static final String DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT;
+      HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_LOG_PURGE_GAP =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_PURGE_GAP;
+  public static final int HDDS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT;
+  public static final String HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT;
   public static final String
-      DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT =
-      ScmConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT;
+      HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT =
+      ScmConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT;
   public static final String
-      DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY =
-      ScmConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY;
+      HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY =
+      ScmConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY;
   public static final TimeDuration
-      DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT =
-      ScmConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT;
-  public static final String DFS_RATIS_SNAPSHOT_THRESHOLD_KEY =
-      ScmConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY;
-  public static final long DFS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT =
-      ScmConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT;
+      HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT =
+      ScmConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT;
+  public static final String HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY =
+      ScmConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY;
+  public static final long HDDS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT =
+      ScmConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT;
 
   public static final String HDDS_DATANODE_PLUGINS_KEY =
       "hdds.datanode.plugins";
diff --git a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/XceiverServerGrpc.java b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/XceiverServerGrpc.java
index 009e6396e0d2..346b05ebb4c1 100644
--- a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/XceiverServerGrpc.java
+++ b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/XceiverServerGrpc.java
@@ -99,11 +99,11 @@ public XceiverServerGrpc(DatanodeDetails datanodeDetails,
 
     this.id = datanodeDetails.getUuid();
     this.datanodeDetails = datanodeDetails;
-    this.port = conf.getInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
-        OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+    this.port = conf.getInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
 
-    if (conf.getBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT,
-        OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT_DEFAULT)) {
+    if (conf.getBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT_DEFAULT)) {
       this.port = 0;
     }
 
diff --git a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/ContainerStateMachine.java b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/ContainerStateMachine.java
index 31e0c603aeed..56210eab7e4d 100644
--- a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/ContainerStateMachine.java
+++ b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/ContainerStateMachine.java
@@ -219,8 +219,8 @@ public ContainerStateMachine(RaftGroupId gid,
     this.writeChunkFutureMap = new ConcurrentHashMap<>();
     applyTransactionCompletionMap = new ConcurrentHashMap<>();
     long pendingRequestsBytesLimit = (long)conf.getStorageSize(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT,
         StorageUnit.BYTES);
     // cache with FIFO eviction, and if element not found, this needs
     // to be obtained from disk for slow follower
@@ -238,13 +238,13 @@ public ContainerStateMachine(RaftGroupId gid,
     this.container2BCSIDMap = new ConcurrentHashMap<>();
 
     final int numContainerOpExecutors = conf.getInt(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_DEFAULT);
     int maxPendingApplyTransactions = conf.getInt(
         ScmConfigKeys.
-            DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS,
+            HDDS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS,
         ScmConfigKeys.
-            DFS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS_DEFAULT);
+            HDDS_CONTAINER_RATIS_STATEMACHINE_MAX_PENDING_APPLY_TXNS_DEFAULT);
     applyTransactionSemaphore = new Semaphore(maxPendingApplyTransactions);
     stateMachineHealthy = new AtomicBoolean(true);
 
diff --git a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/XceiverServerRatis.java b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/XceiverServerRatis.java
index e6cbe262f6a6..58c8655454bd 100644
--- a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/XceiverServerRatis.java
+++ b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/XceiverServerRatis.java
@@ -111,12 +111,12 @@
 import org.slf4j.LoggerFactory;
 
 import static org.apache.hadoop.hdds.DatanodeVersion.SEPARATE_RATIS_PORTS_AVAILABLE;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY;
 import static org.apache.ratis.util.Preconditions.assertTrue;
 
 /**
@@ -172,8 +172,8 @@ private XceiverServerRatis(DatanodeDetails dd,
     ratisServerConfig = conf.getObject(DatanodeRatisServerConfig.class);
     assignPorts();
     this.streamEnable = conf.getBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT);
     this.context = context;
     this.dispatcher = dispatcher;
     this.containerController = containerController;
@@ -200,17 +200,17 @@ private XceiverServerRatis(DatanodeDetails dd,
 
   private void assignPorts() {
     clientPort = determinePort(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT_DEFAULT);
 
     if (DatanodeVersion.fromProtoValue(datanodeDetails.getInitialVersion())
         .compareTo(SEPARATE_RATIS_PORTS_AVAILABLE) >= 0) {
       adminPort = determinePort(
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_ADMIN_PORT,
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_ADMIN_PORT_DEFAULT);
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_ADMIN_PORT,
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_ADMIN_PORT_DEFAULT);
       serverPort = determinePort(
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_SERVER_PORT,
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_SERVER_PORT_DEFAULT);
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_SERVER_PORT,
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_SERVER_PORT_DEFAULT);
     } else {
       adminPort = clientPort;
       serverPort = clientPort;
@@ -219,8 +219,8 @@ private void assignPorts() {
 
   private int determinePort(String key, int defaultValue) {
     boolean randomPort = conf.getBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT_DEFAULT);
     return randomPort ? 0 : conf.getInt(key, defaultValue);
   }
 
@@ -232,14 +232,14 @@ private ContainerStateMachine getStateMachine(RaftGroupId gid) {
   private void setUpRatisStream(RaftProperties properties) {
     // set the datastream config
     if (conf.getBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT,
         OzoneConfigKeys.
-            DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT_DEFAULT)) {
+            HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT_DEFAULT)) {
       dataStreamPort = 0;
     } else {
       dataStreamPort = conf.getInt(
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_PORT,
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_PORT_DEFAULT);
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_PORT,
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_PORT_DEFAULT);
     }
     RatisHelper.enableNettyStreaming(properties);
     NettyConfigKeys.DataStream.setPort(properties, dataStreamPort);
@@ -310,8 +310,8 @@ public RaftProperties newRaftProperties() {
     }
 
     long snapshotThreshold =
-        conf.getLong(OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY,
-            OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT);
+        conf.getLong(OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY,
+            OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_DEFAULT);
     RaftServerConfigKeys.Snapshot.
       setAutoTriggerEnabled(properties, true);
     RaftServerConfigKeys.Snapshot.
@@ -321,11 +321,11 @@ public RaftProperties newRaftProperties() {
     setPendingRequestsLimits(properties);
 
     int logQueueNumElements =
-        conf.getInt(OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS,
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT);
+        conf.getInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS,
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_NUM_ELEMENTS_DEFAULT);
     final long logQueueByteLimit = (long) conf.getStorageSize(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_QUEUE_BYTE_LIMIT_DEFAULT,
         StorageUnit.BYTES);
     RaftServerConfigKeys.Log.setQueueElementLimit(
         properties, logQueueNumElements);
@@ -336,8 +336,8 @@ public RaftProperties newRaftProperties() {
         false);
 
     int purgeGap = conf.getInt(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_PURGE_GAP,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_PURGE_GAP_DEFAULT);
     RaftServerConfigKeys.Log.setPurgeGap(properties, purgeGap);
 
     //Set the number of Snapshots Retained.
@@ -358,12 +358,12 @@ private void setRatisLeaderElectionTimeout(RaftProperties properties) {
     long duration;
     TimeUnit leaderElectionMinTimeoutUnit =
         OzoneConfigKeys.
-            DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT
+            HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT
             .getUnit();
     duration = conf.getTimeDuration(
-        OzoneConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
+        OzoneConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
         OzoneConfigKeys.
-            DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT
+            HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_DEFAULT
             .getDuration(), leaderElectionMinTimeoutUnit);
     final TimeDuration leaderElectionMinTimeout =
         TimeDuration.valueOf(duration, leaderElectionMinTimeoutUnit);
@@ -379,11 +379,11 @@ private void setTimeoutForRetryCache(RaftProperties properties) {
     TimeUnit timeUnit;
     long duration;
     timeUnit =
-        OzoneConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT
+        OzoneConfigKeys.HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT
             .getUnit();
     duration = conf.getTimeDuration(
-        OzoneConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY,
-        OzoneConfigKeys.DFS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT
+        OzoneConfigKeys.HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_KEY,
+        OzoneConfigKeys.HDDS_RATIS_SERVER_RETRY_CACHE_TIMEOUT_DURATION_DEFAULT
             .getDuration(), timeUnit);
     final TimeDuration retryCacheTimeout =
         TimeDuration.valueOf(duration, timeUnit);
@@ -393,8 +393,8 @@ private void setTimeoutForRetryCache(RaftProperties properties) {
 
   private long setRaftSegmentPreallocatedSize(RaftProperties properties) {
     final long raftSegmentPreallocatedSize = (long) conf.getStorageSize(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_KEY,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_SEGMENT_PREALLOCATED_SIZE_DEFAULT,
         StorageUnit.BYTES);
     RaftServerConfigKeys.Log.setPreallocatedSize(properties,
         SizeInBytes.valueOf(raftSegmentPreallocatedSize));
@@ -403,23 +403,23 @@ private long setRaftSegmentPreallocatedSize(RaftProperties properties) {
 
   private void setRaftSegmentAndWriteBufferSize(RaftProperties properties) {
     final int logAppenderQueueNumElements = conf.getInt(
-        DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS,
-        DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT);
+        HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS,
+        HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_NUM_ELEMENTS_DEFAULT);
     final int logAppenderQueueByteLimit = (int) conf.getStorageSize(
-        DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT,
-        DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT,
+        HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT,
+        HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT_DEFAULT,
         StorageUnit.BYTES);
 
     final long raftSegmentSize = (long) conf.getStorageSize(
-        DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY,
-        DFS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT,
+        HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY,
+        HDDS_CONTAINER_RATIS_SEGMENT_SIZE_DEFAULT,
         StorageUnit.BYTES);
     final long raftSegmentBufferSize = logAppenderQueueByteLimit + 8;
 
     assertTrue(raftSegmentBufferSize <= raftSegmentSize,
-        () -> DFS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT + " = "
+        () -> HDDS_CONTAINER_RATIS_LOG_APPENDER_QUEUE_BYTE_LIMIT + " = "
             + logAppenderQueueByteLimit
-            + " must be <= (" + DFS_CONTAINER_RATIS_SEGMENT_SIZE_KEY + " - 8"
+            + " must be <= (" + HDDS_CONTAINER_RATIS_SEGMENT_SIZE_KEY + " - 8"
             + " = " + (raftSegmentSize - 8) + ")");
 
     RaftServerConfigKeys.Log.Appender.setBufferElementLimit(properties,
@@ -437,11 +437,11 @@ private void setStateMachineDataConfigurations(RaftProperties properties) {
     RaftServerConfigKeys.Log.StateMachineData.setSync(properties, true);
 
     TimeUnit timeUnit = OzoneConfigKeys.
-        DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT.getUnit();
+        HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT.getUnit();
     long duration = conf.getTimeDuration(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT,
         OzoneConfigKeys.
-            DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT
+            HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_TIMEOUT_DEFAULT
             .getDuration(), timeUnit);
     final TimeDuration dataSyncTimeout =
         TimeDuration.valueOf(duration, timeUnit);
@@ -462,7 +462,7 @@ private void setStateMachineDataConfigurations(RaftProperties properties) {
     int syncTimeoutRetryDefault = (int) nodeFailureTimeoutMs /
         dataSyncTimeout.toIntExact(TimeUnit.MILLISECONDS);
     int numSyncRetries = conf.getInt(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_STATEMACHINEDATA_SYNC_RETRIES,
         syncTimeoutRetryDefault);
     RaftServerConfigKeys.Log.StateMachineData.setSyncTimeoutRetry(properties,
         numSyncRetries);
@@ -490,8 +490,8 @@ private void setStateMachineDataConfigurations(RaftProperties properties) {
 
   private RpcType setRpcType(RaftProperties properties) {
     final String rpcType = conf.get(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_DEFAULT);
     final RpcType rpc = SupportedRpcType.valueOfIgnoreCase(rpcType);
     RatisHelper.setRpcType(properties, rpc);
     return rpc;
@@ -500,8 +500,8 @@ private RpcType setRpcType(RaftProperties properties) {
   private void setPendingRequestsLimits(RaftProperties properties) {
 
     long pendingRequestsBytesLimit = (long) conf.getStorageSize(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT,
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT,
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_LEADER_PENDING_BYTES_LIMIT_DEFAULT,
         StorageUnit.BYTES);
     final int pendingRequestsMegaBytesLimit =
         HddsUtils.roundupMb(pendingRequestsBytesLimit);
@@ -967,9 +967,9 @@ private static List<ThreadPoolExecutor> createChunkExecutors(
     // TODO create single pool with N threads if using non-incremental chunks
     final int threadCountPerDisk = conf.getInt(
         OzoneConfigKeys
-            .DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY,
+            .HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY,
         OzoneConfigKeys
-            .DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT);
+            .HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT);
 
     final int numberOfDisks =
         HddsServerUtil.getDatanodeStorageDirs(conf).size();
diff --git a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/KeyValueHandler.java b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/KeyValueHandler.java
index c462649c68c7..16da798c807e 100644
--- a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/KeyValueHandler.java
+++ b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/KeyValueHandler.java
@@ -165,9 +165,9 @@ public KeyValueHandler(ConfigurationSource config,
     // Requests.
     final int threadCountPerDisk = conf.getInt(
         OzoneConfigKeys
-            .DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY,
+            .HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY,
         OzoneConfigKeys
-            .DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT);
+            .HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_DEFAULT);
     final int numberOfDisks =
         HddsServerUtil.getDatanodeStorageDirs(conf).size();
     containerCreationLocks = Striped.lazyWeakLock(
diff --git a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/impl/ChunkManagerFactory.java b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/impl/ChunkManagerFactory.java
index 1267ed786892..288a2d3e3312 100644
--- a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/impl/ChunkManagerFactory.java
+++ b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/keyvalue/impl/ChunkManagerFactory.java
@@ -51,8 +51,8 @@ private ChunkManagerFactory() {
   public static ChunkManager createChunkManager(ConfigurationSource conf,
       BlockManager manager, VolumeSet volSet) {
     boolean sync =
-        conf.getBoolean(OzoneConfigKeys.DFS_CONTAINER_CHUNK_WRITE_SYNC_KEY,
-            OzoneConfigKeys.DFS_CONTAINER_CHUNK_WRITE_SYNC_DEFAULT);
+        conf.getBoolean(OzoneConfigKeys.HDDS_CONTAINER_CHUNK_WRITE_SYNC_KEY,
+            OzoneConfigKeys.HDDS_CONTAINER_CHUNK_WRITE_SYNC_DEFAULT);
 
     boolean persist = conf.getBoolean(HDDS_CONTAINER_PERSISTDATA,
         HDDS_CONTAINER_PERSISTDATA_DEFAULT);
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/ContainerTestUtils.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/ContainerTestUtils.java
index 735ad6033fb8..3bba28fe20aa 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/ContainerTestUtils.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/ContainerTestUtils.java
@@ -336,7 +336,7 @@ public static ContainerController getEmptyContainerController() {
 
   public static XceiverServerRatis newXceiverServerRatis(
       DatanodeDetails dn, OzoneConfiguration conf) throws IOException {
-    conf.setInt(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT,
+    conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT,
         dn.getPort(DatanodeDetails.Port.Name.RATIS).getValue());
 
     return XceiverServerRatis.newXceiverServerRatis(dn, conf,
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/SCMTestUtils.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/SCMTestUtils.java
index 91935e0d04b1..36ffbca6584b 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/SCMTestUtils.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/SCMTestUtils.java
@@ -168,8 +168,8 @@ public static HddsProtos.ReplicationFactor getReplicationFactor(
 
   private static boolean isUseRatis(ConfigurationSource c) {
     return c.getBoolean(
-        ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY,
-        ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_DEFAULT);
+        ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_KEY,
+        ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_DEFAULT);
   }
 
 }
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/TestDatanodeStateMachine.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/TestDatanodeStateMachine.java
index 914057f70a34..6c7694556baa 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/TestDatanodeStateMachine.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/TestDatanodeStateMachine.java
@@ -80,12 +80,12 @@ public void setUp() throws Exception {
     conf = SCMTestUtils.getConf();
     conf.setTimeDuration(OZONE_SCM_HEARTBEAT_RPC_TIMEOUT, 500,
         TimeUnit.MILLISECONDS);
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT, true);
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT, true);
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT, true);
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT, true);
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
         true);
     conf.setBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
     serverAddresses = new ArrayList<>();
     scmServers = new ArrayList<>();
     mockServers = new ArrayList<>();
@@ -216,7 +216,7 @@ public void testDatanodeStateContext() throws IOException,
     DatanodeDetails datanodeDetails = getNewDatanodeDetails();
     DatanodeDetails.Port port = DatanodeDetails.newPort(
         DatanodeDetails.Port.Name.STANDALONE,
-        OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
     datanodeDetails.setPort(port);
     ContainerUtils.writeDatanodeDetailsTo(datanodeDetails, idPath, conf);
     try (DatanodeStateMachine stateMachine =
@@ -343,7 +343,7 @@ public void testDatanodeStateMachineWithIdWriteFail() throws Exception {
     DatanodeDetails datanodeDetails = getNewDatanodeDetails();
     DatanodeDetails.Port port = DatanodeDetails.newPort(
         DatanodeDetails.Port.Name.STANDALONE,
-        OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
     datanodeDetails.setPort(port);
 
     try (DatanodeStateMachine stateMachine =
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/statemachine/TestDatanodeConfiguration.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/statemachine/TestDatanodeConfiguration.java
index abfa2c76147a..8946f8baac49 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/statemachine/TestDatanodeConfiguration.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/statemachine/TestDatanodeConfiguration.java
@@ -179,7 +179,7 @@ public void isCreatedWitDefaultValues() {
   public void testConf() throws Exception {
     final OzoneConfiguration conf = new OzoneConfiguration();
     final String dir = "dummy/dir";
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
 
     final DatanodeRatisServerConfig ratisConf = conf.getObject(
         DatanodeRatisServerConfig.class);
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestPeriodicVolumeChecker.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestPeriodicVolumeChecker.java
index 85165548142e..b25162757b35 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestPeriodicVolumeChecker.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestPeriodicVolumeChecker.java
@@ -59,7 +59,7 @@ public class TestPeriodicVolumeChecker {
   public void setup() throws IOException {
     conf = new OzoneConfiguration();
     conf.set(ScmConfigKeys.HDDS_DATANODE_DIR_KEY, folder.toString());
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
         Files.createDirectory(folder.resolve("VolumeCheckerDir")).toString());
   }
 
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSet.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSet.java
index d10e678b572d..b95765d62f6a 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSet.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSet.java
@@ -77,7 +77,7 @@ public void setup() throws Exception {
     volumes.add(volume1);
     volumes.add(volume2);
     conf.set(DFSConfigKeysLegacy.DFS_DATANODE_DATA_DIR_KEY, dataDirKey);
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
         dataDirKey);
     initializeVolumeSet();
   }
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSetDiskChecks.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSetDiskChecks.java
index 832fbcac03ab..c52b2bed4d11 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSetDiskChecks.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/common/volume/TestVolumeSetDiskChecks.java
@@ -230,7 +230,7 @@ private OzoneConfiguration getConfWithDataNodeDirs(int numDirs) {
     for (int i = 0; i < numDirs; ++i) {
       metaDirs.add(GenericTestUtils.getRandomizedTestDir().getPath());
     }
-    ozoneConf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
+    ozoneConf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
         String.join(",", metaDirs));
 
     final List<String> dbDirs = new ArrayList<>();
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestContainerReader.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestContainerReader.java
index b22f3a68516e..25d45c53503b 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestContainerReader.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestContainerReader.java
@@ -323,7 +323,7 @@ public void testMultipleContainerReader() throws Exception {
     BlockUtils.shutdownCache(conf);
     conf.set(ScmConfigKeys.HDDS_DATANODE_DIR_KEY,
         datanodeDirs.toString());
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
         datanodeDirs.toString());
     MutableVolumeSet volumeSets =
         new MutableVolumeSet(datanodeId.toString(), clusterId, conf, null,
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java
index 1384530ff772..a3d2b67b6738 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java
@@ -178,7 +178,7 @@ public void testBuildContainerMap() throws Exception {
   public void testBuildNodeReport() throws Exception {
     String path = folder.getRoot()
             .getAbsolutePath();
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
             String.join(",",
             path + "/ratis1", path + "/ratis2", path + "ratis3"));
 
diff --git a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/upgrade/TestDatanodeUpgradeToSchemaV3.java b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/upgrade/TestDatanodeUpgradeToSchemaV3.java
index 7669a577cf7e..8c8107b4c598 100644
--- a/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/upgrade/TestDatanodeUpgradeToSchemaV3.java
+++ b/hadoop-hdds/container-service/src/test/java/org/apache/hadoop/ozone/container/upgrade/TestDatanodeUpgradeToSchemaV3.java
@@ -105,10 +105,10 @@ public TestDatanodeUpgradeToSchemaV3(Boolean enable) {
     conf = new OzoneConfiguration();
     conf.setBoolean(DatanodeConfiguration.CONTAINER_SCHEMA_V3_ENABLED,
         this.schemaV3Enabled);
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
         true);
     conf.setBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
   }
 
   @Before
diff --git a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HddsServerUtil.java b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HddsServerUtil.java
index 70d394e73b31..4fae3686c93c 100644
--- a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HddsServerUtil.java
+++ b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HddsServerUtil.java
@@ -382,14 +382,14 @@ public static int getLogWarnInterval(ConfigurationSource conf) {
    * @return port number.
    */
   public static int getContainerPort(ConfigurationSource conf) {
-    return conf.getInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
-        OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+    return conf.getInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
   }
 
   public static Collection<String> getOzoneDatanodeRatisDirectory(
       ConfigurationSource conf) {
     Collection<String> rawLocations = conf.getTrimmedStringCollection(
-            OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR);
+            OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR);
 
     if (rawLocations.isEmpty()) {
       rawLocations = new ArrayList<>(1);
diff --git a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/common/TestEndPoint.java b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/common/TestEndPoint.java
index 95ec7914129a..6c4f8d956863 100644
--- a/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/common/TestEndPoint.java
+++ b/hadoop-hdds/server-scm/src/test/java/org/apache/hadoop/ozone/container/common/TestEndPoint.java
@@ -148,10 +148,10 @@ public void testGetVersionTask() throws Exception {
     try (EndpointStateMachine rpcEndPoint = createEndpoint(ozoneConf,
         serverAddress, 1000)) {
       ozoneConf.setBoolean(
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
           true);
       ozoneConf.setBoolean(
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
       OzoneContainer ozoneContainer = new OzoneContainer(dnDetails,
           ozoneConf, ContainerTestUtils.getMockContext(dnDetails, ozoneConf));
       rpcEndPoint.setState(EndpointStateMachine.EndPointStates.GETVERSION);
@@ -177,9 +177,9 @@ public void testGetVersionTask() throws Exception {
    */
   @Test
   public void testDeletedContainersClearedOnStartup() throws Exception {
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT,
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT,
         true);
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT,
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT,
         true);
     ozoneConf.setFromObject(new ReplicationConfig().setPort(0));
     try (EndpointStateMachine rpcEndPoint = createEndpoint(ozoneConf,
@@ -216,12 +216,12 @@ public void testDeletedContainersClearedOnStartup() throws Exception {
 
   @Test
   public void testCheckVersionResponse() throws Exception {
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT,
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT,
         true);
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT,
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT,
         true);
     ozoneConf.setBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
     ozoneConf.setFromObject(new ReplicationConfig().setPort(0));
     try (EndpointStateMachine rpcEndPoint = createEndpoint(ozoneConf,
         serverAddress, 1000)) {
@@ -270,7 +270,7 @@ public void testCheckVersionResponse() throws Exception {
    */
   @Test
   public void testDnLayoutVersionFile() throws Exception {
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT,
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT,
         true);
     try (EndpointStateMachine rpcEndPoint = createEndpoint(ozoneConf,
         serverAddress, 1000)) {
@@ -590,7 +590,7 @@ private StateContext heartbeatTaskHelper(
     // Mini Ozone cluster will not come up if the port is not true, since
     // Ratis will exit if the server port cannot be bound. We can remove this
     // hard coding once we fix the Ratis default behaviour.
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT, true);
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT, true);
 
     // Create a datanode state machine for stateConext used by endpoint task
     try (DatanodeStateMachine stateMachine = new DatanodeStateMachine(
diff --git a/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java b/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java
index 7aa91cec73c8..03c09203c968 100644
--- a/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java
+++ b/hadoop-hdds/tools/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java
@@ -97,8 +97,8 @@ public ContainerOperationClient(OzoneConfiguration conf) throws IOException {
     containerSizeB = (int) conf.getStorageSize(OZONE_SCM_CONTAINER_SIZE,
         OZONE_SCM_CONTAINER_SIZE_DEFAULT, StorageUnit.BYTES);
     boolean useRatis = conf.getBoolean(
-        ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY,
-        ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_DEFAULT);
+        ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_KEY,
+        ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_DEFAULT);
     if (useRatis) {
       replicationFactor = HddsProtos.ReplicationFactor.THREE;
       replicationType = HddsProtos.ReplicationType.RATIS;
diff --git a/hadoop-ozone/fault-injection-test/mini-chaos-tests/src/test/java/org/apache/hadoop/ozone/MiniOzoneChaosCluster.java b/hadoop-ozone/fault-injection-test/mini-chaos-tests/src/test/java/org/apache/hadoop/ozone/MiniOzoneChaosCluster.java
index 1ffed5323aab..fa0ae0251b48 100644
--- a/hadoop-ozone/fault-injection-test/mini-chaos-tests/src/test/java/org/apache/hadoop/ozone/MiniOzoneChaosCluster.java
+++ b/hadoop-ozone/fault-injection-test/mini-chaos-tests/src/test/java/org/apache/hadoop/ozone/MiniOzoneChaosCluster.java
@@ -261,10 +261,10 @@ protected void initializeConfiguration() throws IOException {
           TimeUnit.SECONDS);
       conf.setInt(
           OzoneConfigKeys
-              .DFS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY,
+              .HDDS_CONTAINER_RATIS_NUM_WRITE_CHUNK_THREADS_PER_VOLUME_KEY,
           4);
       conf.setInt(
-          OzoneConfigKeys.DFS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY,
+          OzoneConfigKeys.HDDS_CONTAINER_RATIS_NUM_CONTAINER_OP_EXECUTORS_KEY,
           2);
       conf.setInt(OzoneConfigKeys.OZONE_CONTAINER_CACHE_SIZE, 2);
       ReplicationManagerConfiguration replicationConf =
@@ -273,8 +273,8 @@ protected void initializeConfiguration() throws IOException {
       replicationConf.setEventTimeout(Duration.ofSeconds(20));
       replicationConf.setDatanodeTimeoutOffset(0);
       conf.setFromObject(replicationConf);
-      conf.setInt(OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY, 100);
-      conf.setInt(OzoneConfigKeys.DFS_CONTAINER_RATIS_LOG_PURGE_GAP, 100);
+      conf.setInt(OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY, 100);
+      conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_LOG_PURGE_GAP, 100);
       conf.setInt(OMConfigKeys.OZONE_OM_RATIS_LOG_PURGE_GAP, 100);
 
       conf.setInt(OMConfigKeys.
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithStreaming.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithStreaming.java
index 5d068546828f..ec9e8349b121 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithStreaming.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestOzoneFileSystemWithStreaming.java
@@ -44,7 +44,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_FS_DATASTREAM_AUTO_THRESHOLD;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_FS_DATASTREAM_ENABLED;
 import static org.apache.hadoop.ozone.OzoneConsts.OZONE_OFS_URI_SCHEME;
@@ -79,7 +79,7 @@ public static void init() throws Exception {
     final int blockSize = 2 * maxFlushSize;
     final BucketLayout layout = BucketLayout.FILE_SYSTEM_OPTIMIZED;
 
-    CONF.setBoolean(DFS_CONTAINER_RATIS_DATASTREAM_ENABLED, true);
+    CONF.setBoolean(HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED, true);
     CONF.setBoolean(OZONE_FS_DATASTREAM_ENABLED, true);
     CONF.set(OZONE_FS_DATASTREAM_AUTO_THRESHOLD, AUTO_THRESHOLD + "B");
     CONF.setBoolean(OZONE_OM_RATIS_ENABLE_KEY, true);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestRatisPipelineLeader.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestRatisPipelineLeader.java
index 00b7d3535cd4..e50f0d2961ee 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestRatisPipelineLeader.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestRatisPipelineLeader.java
@@ -32,7 +32,7 @@
 import org.apache.hadoop.ozone.container.common.transport.server.ratis.XceiverServerRatis;
 import org.apache.ozone.test.GenericTestUtils;
 
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY;
 import org.apache.ratis.protocol.ClientId;
 import org.apache.ratis.protocol.GroupInfoReply;
 import org.apache.ratis.protocol.GroupInfoRequest;
@@ -132,7 +132,7 @@ public void testLeaderIdAfterLeaderChange() throws Exception {
     dnToStop.get().stop();
     // wait long enough based on leader election min timeout
     Thread.sleep(4000 * conf.getTimeDuration(
-        DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
+        HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
         5, TimeUnit.SECONDS));
     GenericTestUtils.waitFor(() -> {
       try {
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/MiniOzoneClusterImpl.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/MiniOzoneClusterImpl.java
index a19c8bef96e4..5402c773a11f 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/MiniOzoneClusterImpl.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/MiniOzoneClusterImpl.java
@@ -95,11 +95,11 @@
 import static org.apache.hadoop.ozone.MiniOzoneCluster.PortAllocator.anyHostWithFreePort;
 import static org.apache.hadoop.ozone.MiniOzoneCluster.PortAllocator.getFreePort;
 import static org.apache.hadoop.ozone.MiniOzoneCluster.PortAllocator.localhostWithFreePort;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_IPC_PORT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_ADMIN_PORT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_PORT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_SERVER_PORT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_ADMIN_PORT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_PORT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_SERVER_PORT;
 import static org.apache.hadoop.ozone.om.OmUpgradeConfig.ConfigStrings.OZONE_OM_INIT_DEFAULT_LAYOUT_VERSION;
 import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_DB_DIR;
 import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_OM_SNAPSHOT_DB_DIR;
@@ -870,7 +870,7 @@ protected List<HddsDatanodeService> createHddsDatanodes(
         dnConf.set(ScmConfigKeys.HDDS_DATANODE_DIR_KEY, listOfDirs);
         dnConf.set(ScmConfigKeys.HDDS_DATANODE_DIR_DU_RESERVED,
             reservedSpaceString);
-        dnConf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
+        dnConf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR,
             ratisDir.toString());
         if (reconServer != null) {
           OzoneStorageContainerManager reconScm =
@@ -948,7 +948,7 @@ private void configureOM() {
     }
 
     private void configureHddsDatanodes() {
-      conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+      conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
           enableContainerDatastream);
     }
 
@@ -959,11 +959,11 @@ protected void configureDatanodePorts(ConfigurationTarget conf) {
           anyHostWithFreePort());
       conf.set(HddsConfigKeys.HDDS_DATANODE_CLIENT_ADDRESS_KEY,
           anyHostWithFreePort());
-      conf.setInt(DFS_CONTAINER_IPC_PORT, getFreePort());
-      conf.setInt(DFS_CONTAINER_RATIS_IPC_PORT, getFreePort());
-      conf.setInt(DFS_CONTAINER_RATIS_ADMIN_PORT, getFreePort());
-      conf.setInt(DFS_CONTAINER_RATIS_SERVER_PORT, getFreePort());
-      conf.setInt(DFS_CONTAINER_RATIS_DATASTREAM_PORT, getFreePort());
+      conf.setInt(HDDS_CONTAINER_IPC_PORT, getFreePort());
+      conf.setInt(HDDS_CONTAINER_RATIS_IPC_PORT, getFreePort());
+      conf.setInt(HDDS_CONTAINER_RATIS_ADMIN_PORT, getFreePort());
+      conf.setInt(HDDS_CONTAINER_RATIS_SERVER_PORT, getFreePort());
+      conf.setInt(HDDS_CONTAINER_RATIS_DATASTREAM_PORT, getFreePort());
       conf.setFromObject(new ReplicationConfig().setPort(getFreePort()));
     }
 
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/RatisTestHelper.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/RatisTestHelper.java
index 3f94387e1c6a..a010dd0b94b8 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/RatisTestHelper.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/RatisTestHelper.java
@@ -100,11 +100,11 @@ static OzoneConfiguration newOzoneConfiguration(RpcType rpc) {
   }
 
   static void initRatisConf(RpcType rpc, OzoneConfiguration conf) {
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY, true);
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY, rpc.name());
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_KEY, true);
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY, rpc.name());
     conf.setTimeDuration(HDDS_CONTAINER_REPORT_INTERVAL, 1, TimeUnit.SECONDS);
     conf.setTimeDuration(OZONE_SCM_STALENODE_INTERVAL, 30, TimeUnit.SECONDS);
-    LOG.info("{} = {}", OzoneConfigKeys.DFS_CONTAINER_RATIS_RPC_TYPE_KEY,
+    LOG.info("{} = {}", OzoneConfigKeys.HDDS_CONTAINER_RATIS_RPC_TYPE_KEY,
             rpc.name());
   }
 
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMiniOzoneCluster.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMiniOzoneCluster.java
index b8cf7906c0a2..af0fa0fbfdc2 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMiniOzoneCluster.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestMiniOzoneCluster.java
@@ -48,7 +48,7 @@
 
 import static org.apache.hadoop.hdds.protocol.DatanodeDetails.Port;
 import static org.apache.hadoop.hdds.protocol.MockDatanodeDetails.randomDatanodeDetails;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
@@ -68,7 +68,7 @@ static void setup(@TempDir File testDir) {
     conf = new OzoneConfiguration();
     conf.set(HddsConfigKeys.OZONE_METADATA_DIRS, testDir.getAbsolutePath());
     conf.setInt(ScmConfigKeys.OZONE_DATANODE_PIPELINE_LIMIT, 1);
-    conf.setBoolean(DFS_CONTAINER_RATIS_IPC_RANDOM_PORT, true);
+    conf.setBoolean(HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT, true);
     conf.set(ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL, "1s");
   }
 
@@ -114,13 +114,13 @@ public void testContainerRandomPort() throws IOException {
 
     // Each instance of SM will create an ozone container
     // that bounds to a random port.
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT, true);
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_RANDOM_PORT,
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT, true);
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_RANDOM_PORT,
         true);
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
         true);
     ozoneConf.setBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
     List<DatanodeStateMachine> stateMachines = new ArrayList<>();
     try {
 
@@ -168,7 +168,7 @@ public void testContainerRandomPort() throws IOException {
     }
 
     // Turn off the random port flag and test again
-    ozoneConf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT, false);
+    ozoneConf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT, false);
     try (
         DatanodeStateMachine sm1 = new DatanodeStateMachine(
             randomDatanodeDetails(), ozoneConf);
@@ -182,8 +182,8 @@ public void testContainerRandomPort() throws IOException {
       assertFalse(ports.add(sm2.getContainer().getReadChannel().getIPCPort()));
       assertFalse(ports.add(sm3.getContainer().getReadChannel().getIPCPort()));
       assertEquals(ports.iterator().next().intValue(),
-          conf.getInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
-              OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT));
+          conf.getInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+              OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT));
     }
   }
 
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
index 7c0fcd43722d..423c91d5db9d 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
@@ -106,7 +106,7 @@ public void setup() throws Exception {
     conf.setTimeDuration(OZONE_SCM_STALENODE_INTERVAL, 3, TimeUnit.SECONDS);
     conf.setQuietMode(false);
     OzoneManager.setTestSecureOmFlag(true);
-    conf.setLong(OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
+    conf.setLong(OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
     conf.set(OzoneConfigKeys.OZONE_SCM_CLOSE_CONTAINER_WAIT_DURATION, "2s");
     conf.set(ScmConfigKeys.OZONE_SCM_PIPELINE_SCRUB_INTERVAL, "2s");
     conf.set(ScmConfigKeys.OZONE_SCM_PIPELINE_DESTROY_TIMEOUT, "5s");
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
index 717304a5d0ae..3485df8bcc0e 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
@@ -158,7 +158,7 @@ public static void init() throws Exception {
     raftClientConfig.setRpcWatchRequestTimeout(Duration.ofSeconds(20));
     conf.setFromObject(raftClientConfig);
 
-    conf.setLong(OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
+    conf.setLong(OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
     conf.setQuietMode(false);
     cluster =
         MiniOzoneCluster.newBuilder(conf).setNumDatanodes(10).setHbInterval(200)
@@ -298,9 +298,9 @@ public void testContainerStateMachineFailures() throws Exception {
     // restart the hdds datanode, container should not in the regular set
     OzoneConfiguration config = dn.getConf();
     final String dir = config.get(OzoneConfigKeys.
-            DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR)
+            HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR)
             + UUID.randomUUID();
-    config.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    config.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
     int index = cluster.getHddsDatanodeIndex(dn.getDatanodeDetails());
     cluster.restartHddsDatanode(dn.getDatanodeDetails(), false);
     ozoneContainer = cluster.getHddsDatanodes().get(index)
@@ -363,9 +363,9 @@ public void testUnhealthyContainer() throws Exception {
 
     OzoneConfiguration config = dn.getConf();
     final String dir = config.get(OzoneConfigKeys.
-            DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR)
+            HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR)
             + UUID.randomUUID();
-    config.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    config.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
     int index = cluster.getHddsDatanodeIndex(dn.getDatanodeDetails());
     // restart the hdds datanode and see if the container is listed in the
     // in the missing container set and not in the regular set
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFlushDelay.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFlushDelay.java
index c24f209cdeb1..0cbf996f807d 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFlushDelay.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFlushDelay.java
@@ -110,7 +110,7 @@ public void setup() throws Exception {
     conf.setTimeDuration(OZONE_SCM_STALENODE_INTERVAL, 3, TimeUnit.SECONDS);
     conf.setQuietMode(false);
     OzoneManager.setTestSecureOmFlag(true);
-    conf.setLong(OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
+    conf.setLong(OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
     //  conf.set(HADOOP_SECURITY_AUTHENTICATION, KERBEROS.toString());
     conf.set(OzoneConfigKeys.OZONE_SCM_CLOSE_CONTAINER_WAIT_DURATION, "2s");
     conf.set(ScmConfigKeys.OZONE_SCM_PIPELINE_SCRUB_INTERVAL, "2s");
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineStream.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineStream.java
index aa755bf6939f..f077ceca3724 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineStream.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineStream.java
@@ -121,7 +121,7 @@ public void setup() throws Exception {
     raftClientConfig.setRpcWatchRequestTimeout(Duration.ofSeconds(10));
     conf.setFromObject(raftClientConfig);
 
-    conf.setLong(OzoneConfigKeys.DFS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
+    conf.setLong(OzoneConfigKeys.HDDS_RATIS_SNAPSHOT_THRESHOLD_KEY, 1);
     conf.setQuietMode(false);
     cluster =
         MiniOzoneCluster.newBuilder(conf)
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
index 911650390fad..570d3d40b32c 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
@@ -108,7 +108,7 @@ private void init() throws Exception {
     conf.setFromObject(ratisClientConfig);
 
     conf.setTimeDuration(
-        OzoneConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
+        OzoneConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
         1, TimeUnit.SECONDS);
     conf.setBoolean(
         OzoneConfigKeys.OZONE_NETWORK_TOPOLOGY_AWARE_READ_KEY, true);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
index c9183400032c..f361a30a6289 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
@@ -111,7 +111,7 @@ private void init() throws Exception {
     conf.setFromObject(ratisClientConfig);
 
     conf.setTimeDuration(
-        OzoneConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
+        OzoneConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
         1, TimeUnit.SECONDS);
     conf.setBoolean(
         OzoneConfigKeys.OZONE_NETWORK_TOPOLOGY_AWARE_READ_KEY, true);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
index d7600fa2a851..88c7c4be18bb 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
@@ -114,7 +114,7 @@ private void startCluster(int datanodes) throws Exception {
     conf.setFromObject(ratisClientConfig);
 
     conf.setTimeDuration(
-        OzoneConfigKeys.DFS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
+        OzoneConfigKeys.HDDS_RATIS_LEADER_ELECTION_MINIMUM_TIMEOUT_DURATION_KEY,
         1, TimeUnit.SECONDS);
     conf.setInt(OZONE_DATANODE_PIPELINE_LIMIT, 2);
 
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java
index db0c785fc647..b6f61e1252be 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/common/transport/server/ratis/TestCSMMetrics.java
@@ -184,10 +184,10 @@ static void runContainerStateMachineMetrics(
 
   static XceiverServerRatis newXceiverServerRatis(
       DatanodeDetails dn, OzoneConfiguration conf) throws IOException {
-    conf.setInt(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT,
+    conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT,
         dn.getPort(DatanodeDetails.Port.Name.RATIS).getValue());
     final String dir = TEST_DIR + dn.getUuid();
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
 
     final ContainerDispatcher dispatcher = new TestContainerDispatcher();
     return XceiverServerRatis.newXceiverServerRatis(dn, conf, dispatcher,
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
index cbbbbebe9e13..2d3a0b220ef5 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
@@ -86,7 +86,7 @@ public void testContainerMetrics() throws Exception {
       Pipeline pipeline = MockPipeline
           .createSingleNodePipeline();
       OzoneConfiguration conf = new OzoneConfiguration();
-      conf.setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
+      conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
           pipeline.getFirstNode()
               .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue());
       conf.setInt(DFSConfigKeysLegacy.DFS_METRICS_PERCENTILES_INTERVALS_KEY,
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java
index 4eb57003df08..8962246d71bd 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestOzoneContainer.java
@@ -69,7 +69,7 @@ public void testCreateOzoneContainer() throws Exception {
       Pipeline pipeline = MockPipeline.createSingleNodePipeline();
       conf.set(OZONE_METADATA_DIRS, tempFolder.newFolder().getPath());
       conf.set(HDDS_DATANODE_DIR_KEY, tempFolder.newFolder().getPath());
-      conf.setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
+      conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
           pipeline.getFirstNode()
               .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue());
 
@@ -99,7 +99,7 @@ public void testOzoneContainerStart() throws Exception {
       Pipeline pipeline = MockPipeline.createSingleNodePipeline();
       conf.set(OZONE_METADATA_DIRS, tempFolder.newFolder().getPath());
       conf.set(HDDS_DATANODE_DIR_KEY, tempFolder.newFolder().getPath());
-      conf.setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
+      conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
           pipeline.getFirstNode()
               .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue());
 
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestSecureOzoneContainer.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestSecureOzoneContainer.java
index 715b0678a173..4f24f8e6c320 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestSecureOzoneContainer.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/ozoneimpl/TestSecureOzoneContainer.java
@@ -129,10 +129,10 @@ void testCreateOzoneContainer(boolean requireToken, boolean hasToken,
     try {
       Pipeline pipeline = MockPipeline.createSingleNodePipeline();
       conf.set(HDDS_DATANODE_DIR_KEY, tempFolder.toString());
-      conf.setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT, pipeline
+      conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT, pipeline
           .getFirstNode().getPort(DatanodeDetails.Port.Name.STANDALONE)
           .getValue());
-      conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_IPC_RANDOM_PORT, false);
+      conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_IPC_RANDOM_PORT, false);
 
       DatanodeDetails dn = MockDatanodeDetails.randomDatanodeDetails();
       container = new OzoneContainer(dn, conf, ContainerTestUtils
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestContainerServer.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestContainerServer.java
index 7e5db1f8e570..020d04bbea80 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestContainerServer.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestContainerServer.java
@@ -107,7 +107,7 @@ public static void tearDown() throws Exception {
   public void testClientServer() throws Exception {
     DatanodeDetails datanodeDetails = randomDatanodeDetails();
     runTestClientServer(1, (pipeline, conf) -> conf
-            .setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
+            .setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
                 pipeline.getFirstNode()
                     .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue()),
         XceiverClientGrpc::new,
@@ -124,10 +124,10 @@ public void testClientServerRatisGrpc() throws Exception {
 
   static XceiverServerRatis newXceiverServerRatis(
       DatanodeDetails dn, OzoneConfiguration conf) throws IOException {
-    conf.setInt(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT,
+    conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT,
         dn.getPort(DatanodeDetails.Port.Name.RATIS).getValue());
     final String dir = TEST_DIR + dn.getUuid();
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
 
     final ContainerDispatcher dispatcher = new TestContainerDispatcher();
     return XceiverServerRatis.newXceiverServerRatis(dn, conf, dispatcher,
@@ -219,7 +219,7 @@ public void testClientServerWithContainerDispatcher() throws Exception {
     HddsDispatcher hddsDispatcher = createDispatcher(dd,
         UUID.randomUUID(), CONF);
     runTestClientServer(1, (pipeline, conf) -> conf
-            .setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
+            .setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
                 pipeline.getFirstNode()
                     .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue()),
         XceiverClientGrpc::new,
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestSecureContainerServer.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestSecureContainerServer.java
index 70c5be967f2b..dd65dad6842f 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestSecureContainerServer.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/server/TestSecureContainerServer.java
@@ -160,7 +160,7 @@ public void testClientServer() throws Exception {
     HddsDispatcher hddsDispatcher = createDispatcher(dd,
         UUID.randomUUID(), CONF);
     runTestClientServer(1, (pipeline, conf) -> conf
-            .setInt(OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
+            .setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
                 pipeline.getFirstNode()
                     .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue()),
         XceiverClientGrpc::new,
@@ -203,14 +203,14 @@ public void testClientServerRatisGrpc() throws Exception {
 
   static XceiverServerRatis newXceiverServerRatis(
       DatanodeDetails dn, OzoneConfiguration conf) throws IOException {
-    conf.setInt(OzoneConfigKeys.DFS_CONTAINER_RATIS_IPC_PORT,
+    conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT,
         dn.getPort(DatanodeDetails.Port.Name.RATIS).getValue());
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
         true);
     conf.setBoolean(
-        OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
+        OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_RANDOM_PORT, true);
     final String dir = TEST_DIR + dn.getUuid();
-    conf.set(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    conf.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
     final ContainerDispatcher dispatcher = createDispatcher(dn,
         UUID.randomUUID(), conf);
     return XceiverServerRatis.newXceiverServerRatis(dn, conf, dispatcher,
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/dn/ratis/TestDnRatisLogParser.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/dn/ratis/TestDnRatisLogParser.java
index 076d89c9f89f..f436a49cb3da 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/dn/ratis/TestDnRatisLogParser.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/dn/ratis/TestDnRatisLogParser.java
@@ -79,7 +79,7 @@ public void destroy() throws Exception {
   public void testRatisLogParsing() throws Exception {
     OzoneConfiguration conf = cluster.getHddsDatanodes().get(0).getConf();
     String path =
-        conf.get(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATANODE_STORAGE_DIR);
+        conf.get(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR);
     UUID pid = cluster.getStorageContainerManager().getPipelineManager()
         .getPipelines().get(0).getId().getId();
     File pipelineDir = new File(path, pid.toString());
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestScmAdminHA.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestScmAdminHA.java
index 16c664c8111f..ed1b485e30fa 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestScmAdminHA.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestScmAdminHA.java
@@ -58,7 +58,7 @@ public static void init() throws Exception {
         .build();
     conf.setQuietMode(false);
     // enable ratis for Scm.
-    conf.setBoolean(ScmConfigKeys.DFS_CONTAINER_RATIS_ENABLED_KEY, true);
+    conf.setBoolean(ScmConfigKeys.HDDS_CONTAINER_RATIS_ENABLED_KEY, true);
     cluster.waitForClusterToBeReady();
   }
 
diff --git a/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicOzoneClientAdapterImpl.java b/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicOzoneClientAdapterImpl.java
index 9cd09ea1f3b2..53dc21104657 100644
--- a/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicOzoneClientAdapterImpl.java
+++ b/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicOzoneClientAdapterImpl.java
@@ -189,8 +189,8 @@ public BasicOzoneClientAdapterImpl(String omHost, int omPort,
     OzoneFSUtils.validateBucketLayout(bucket.getName(), resolvedBucketLayout);
 
     this.configuredDnPort = conf.getInt(
-        OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
-        OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+        OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
     this.config = conf;
   }
 
diff --git a/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicRootedOzoneClientAdapterImpl.java b/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicRootedOzoneClientAdapterImpl.java
index 44777cda5c05..b650310ef1db 100644
--- a/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicRootedOzoneClientAdapterImpl.java
+++ b/hadoop-ozone/ozonefs-common/src/main/java/org/apache/hadoop/fs/ozone/BasicRootedOzoneClientAdapterImpl.java
@@ -196,8 +196,8 @@ public BasicRootedOzoneClientAdapterImpl(String omHost, int omPort,
       proxy = objectStore.getClientProxy();
 
       this.configuredDnPort = conf.getInt(
-          OzoneConfigKeys.DFS_CONTAINER_IPC_PORT,
-          OzoneConfigKeys.DFS_CONTAINER_IPC_PORT_DEFAULT);
+          OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+          OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT_DEFAULT);
 
       // Fetches the bucket layout to be used by OFS.
       initDefaultFsBucketLayout(conf);
diff --git a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java
index 600888f0f91f..44b53f5bd877 100644
--- a/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java
+++ b/hadoop-ozone/s3gateway/src/main/java/org/apache/hadoop/ozone/s3/endpoint/ObjectEndpoint.java
@@ -105,8 +105,8 @@
 import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationType.EC;
 import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_CHUNK_SIZE_DEFAULT;
 import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_CHUNK_SIZE_KEY;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED;
-import static org.apache.hadoop.ozone.OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED;
+import static org.apache.hadoop.ozone.OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_FS_DATASTREAM_AUTO_THRESHOLD;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_FS_DATASTREAM_AUTO_THRESHOLD_DEFAULT;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_REPLICATION;
@@ -197,8 +197,8 @@ public void init() {
         OZONE_SCM_CHUNK_SIZE_DEFAULT,
         StorageUnit.BYTES);
     datastreamEnabled = ozoneConfiguration.getBoolean(
-        DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
-        DFS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT);
+        HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+        HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED_DEFAULT);
     datastreamMinLength = (long) ozoneConfiguration.getStorageSize(
         OZONE_FS_DATASTREAM_AUTO_THRESHOLD,
         OZONE_FS_DATASTREAM_AUTO_THRESHOLD_DEFAULT, StorageUnit.BYTES);
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java
index 73efda94ae1f..824ae1bfc57a 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestPartUploadWithStream.java
@@ -68,7 +68,7 @@ public static void setUp() throws Exception {
     REST.setClient(client);
 
     OzoneConfiguration conf = new OzoneConfiguration();
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
         true);
     REST.setOzoneConfiguration(conf);
     REST.init();
diff --git a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java
index 73f45f2566df..25b5c968dc77 100644
--- a/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java
+++ b/hadoop-ozone/s3gateway/src/test/java/org/apache/hadoop/ozone/s3/endpoint/TestUploadWithStream.java
@@ -81,7 +81,7 @@ public static void setUp() throws Exception {
     REST.setClient(client);
 
     OzoneConfiguration conf = new OzoneConfiguration();
-    conf.setBoolean(OzoneConfigKeys.DFS_CONTAINER_RATIS_DATASTREAM_ENABLED,
+    conf.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED,
         true);
     conf.setStorageSize(OZONE_FS_DATASTREAM_AUTO_THRESHOLD, 1,
         StorageUnit.BYTES);

From e26d0e471dbfe9423b3081f8fc3380754caf54fe Mon Sep 17 00:00:00 2001
From: Sadanand Shenoy <sadanand.shenoy4898@gmail.com>
Date: Fri, 12 Jul 2024 16:11:03 +0800
Subject: [PATCH 5/9] HDDS-11069. Block location is missing in output of Ozone
 debug chunkinfo command for EC. (#6909)

(cherry picked from commit a8c377f1fba68c024ff82dbe08c800be6392ec4f)
---
 .../hadoop/hdds/scm/XceiverClientGrpc.java    | 24 +++++++++++++++
 .../ozone/shell/TestOzoneDebugShell.java      | 29 +++++++++++++------
 .../hadoop/ozone/debug/ChunkKeyHandler.java   |  2 +-
 3 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java b/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java
index e8bc12e64162..5defd821a56b 100644
--- a/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java
+++ b/hadoop-hdds/client/src/main/java/org/apache/hadoop/hdds/scm/XceiverClientGrpc.java
@@ -282,6 +282,7 @@ public ContainerCommandResponseProto sendCommand(
     }
     for (DatanodeDetails dn : datanodeList) {
       try {
+        request = reconstructRequestIfNeeded(request, dn);
         futureHashMap.put(dn, sendCommandAsync(request, dn).getResponse());
       } catch (InterruptedException e) {
         LOG.error("Command execution was interrupted.");
@@ -313,6 +314,29 @@ public ContainerCommandResponseProto sendCommand(
     return responseProtoHashMap;
   }
 
+  /**
+   * @param request
+   * @param dn
+   * @param pipeline
+   * In case of getBlock for EC keys, it is required to set replicaIndex for
+   * every request with the replicaIndex for that DN for which the request is
+   * sent to. This method unpacks proto and reconstructs request after setting
+   * the replicaIndex field.
+   * @return new updated Request
+   */
+  private ContainerCommandRequestProto reconstructRequestIfNeeded(
+      ContainerCommandRequestProto request, DatanodeDetails dn) {
+    boolean isEcRequest = pipeline.getReplicationConfig()
+        .getReplicationType() == HddsProtos.ReplicationType.EC;
+    if (request.hasGetBlock() && isEcRequest) {
+      ContainerProtos.GetBlockRequestProto gbr = request.getGetBlock();
+      request = request.toBuilder().setGetBlock(gbr.toBuilder().setBlockID(
+          gbr.getBlockID().toBuilder().setReplicaIndex(
+              pipeline.getReplicaIndex(dn)).build()).build()).build();
+    }
+    return request;
+  }
+
   @Override
   public ContainerCommandResponseProto sendCommand(
       ContainerCommandRequestProto request, List<Validator> validators)
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestOzoneDebugShell.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestOzoneDebugShell.java
index 16963fdb3538..288763c6bbfb 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestOzoneDebugShell.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/shell/TestOzoneDebugShell.java
@@ -21,6 +21,8 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hdds.client.ECReplicationConfig;
+import org.apache.hadoop.hdds.client.ReplicationConfig;
 import org.apache.hadoop.hdds.client.ReplicationFactor;
 import org.apache.hadoop.hdds.client.ReplicationType;
 import org.apache.hadoop.hdds.conf.OzoneConfiguration;
@@ -46,6 +48,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.ValueSource;
 import picocli.CommandLine;
 
 import java.io.File;
@@ -88,7 +92,7 @@ protected static void startCluster() throws Exception {
     omServiceId = "om-service-test1";
     clusterId = UUID.randomUUID().toString();
     scmId = UUID.randomUUID().toString();
-    final int numDNs = 3;
+    final int numDNs = 5;
     cluster = MiniOzoneCluster.newBuilder(conf)
         .setClusterId(clusterId)
         .setScmId(scmId)
@@ -117,13 +121,14 @@ public static void init() throws Exception {
     startCluster();
   }
 
-  @Test
-  public void testChunkInfoCmdBeforeAfterCloseContainer() throws Exception {
+  @ParameterizedTest
+  @ValueSource(booleans = {true, false})
+  public void testChunkInfoCmdBeforeAfterCloseContainer(boolean isEcKey) throws Exception {
     final String volumeName = UUID.randomUUID().toString();
     final String bucketName = UUID.randomUUID().toString();
     final String keyName = UUID.randomUUID().toString();
 
-    writeKey(volumeName, bucketName, keyName);
+    writeKey(volumeName, bucketName, keyName, isEcKey);
 
     int exitCode = runChunkInfoCommand(volumeName, bucketName, keyName);
     Assertions.assertEquals(0, exitCode);
@@ -139,7 +144,7 @@ public void testChunkInfoVerifyPathsAreDifferent() throws Exception {
     final String volumeName = UUID.randomUUID().toString();
     final String bucketName = UUID.randomUUID().toString();
     final String keyName = UUID.randomUUID().toString();
-    writeKey(volumeName, bucketName, keyName);
+    writeKey(volumeName, bucketName, keyName, false);
     int exitCode = runChunkInfoAndVerifyPaths(volumeName, bucketName, keyName);
     Assertions.assertEquals(0, exitCode);
   }
@@ -155,7 +160,7 @@ public void testLdbCliForOzoneSnapshot() throws Exception {
     final String bucketName = UUID.randomUUID().toString();
     final String keyName = UUID.randomUUID().toString();
 
-    writeKey(volumeName, bucketName, keyName);
+    writeKey(volumeName, bucketName, keyName, false);
 
     String snapshotName =
         client.getObjectStore().createSnapshot(volumeName, bucketName, "snap1");
@@ -181,14 +186,20 @@ private static String getSnapshotDBPath(String checkPointDir) {
         OM_DB_NAME + checkPointDir;
   }
 
-
   private static void writeKey(String volumeName, String bucketName,
-      String keyName) throws IOException {
+      String keyName, boolean isEcKey) throws IOException {
+    ReplicationConfig repConfig;
+    if (isEcKey) {
+      repConfig = new ECReplicationConfig(3, 2);
+    } else {
+      repConfig = ReplicationConfig.fromTypeAndFactor(ReplicationType.RATIS,
+          ReplicationFactor.THREE);
+    }
     try (OzoneClient client = OzoneClientFactory.getRpcClient(conf)) {
       TestDataUtil.createVolumeAndBucket(client, volumeName, bucketName);
       TestDataUtil.createKey(
           client.getObjectStore().getVolume(volumeName).getBucket(bucketName),
-          keyName, ReplicationFactor.THREE, ReplicationType.RATIS, "test");
+          keyName, repConfig, "test");
     }
   }
 
diff --git a/hadoop-ozone/tools/src/main/java/org/apache/hadoop/ozone/debug/ChunkKeyHandler.java b/hadoop-ozone/tools/src/main/java/org/apache/hadoop/ozone/debug/ChunkKeyHandler.java
index 2c55b4ea4c73..9d5f0aec11e9 100644
--- a/hadoop-ozone/tools/src/main/java/org/apache/hadoop/ozone/debug/ChunkKeyHandler.java
+++ b/hadoop-ozone/tools/src/main/java/org/apache/hadoop/ozone/debug/ChunkKeyHandler.java
@@ -120,7 +120,7 @@ protected void execute(OzoneClient client, OzoneAddress address)
             keyPipeline.getReplicationConfig().getReplicationType() ==
                 HddsProtos.ReplicationType.EC;
         Pipeline pipeline;
-        if (keyPipeline.getType() != HddsProtos.ReplicationType.STAND_ALONE) {
+        if (!isECKey && keyPipeline.getType() != HddsProtos.ReplicationType.STAND_ALONE) {
           pipeline = Pipeline.newBuilder(keyPipeline)
               .setReplicationConfig(StandaloneReplicationConfig
                   .getInstance(ONE)).build();

From 6a87cfa14cfd82ffdbda6201dad187acbbf8e3c0 Mon Sep 17 00:00:00 2001
From: Chung En Lee <wfps1210@gmail.com>
Date: Tue, 16 Jul 2024 14:17:06 +0800
Subject: [PATCH 6/9] HDDS-10907. DataNode StorageContainerMetrics
 numWriteChunk is counted multiple times (#6835)

Co-authored-by: Doroszlai, Attila <adoroszlai@apache.org>

(cherry picked from commit 63a232b798c2eba71f19bafc607c20c8144a41af)
---
 .../container/common/impl/HddsDispatcher.java |  11 +-
 .../metrics/TestContainerMetrics.java         | 217 ++++++++++++------
 2 files changed, 157 insertions(+), 71 deletions(-)

diff --git a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/impl/HddsDispatcher.java b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/impl/HddsDispatcher.java
index a0f2735c6008..1b60dad694b9 100644
--- a/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/impl/HddsDispatcher.java
+++ b/hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/container/common/impl/HddsDispatcher.java
@@ -202,7 +202,6 @@ private ContainerCommandResponseProto dispatchRequest(
     long startTime = Time.monotonicNow();
     Type cmdType = msg.getCmdType();
     long containerID = msg.getContainerID();
-    metrics.incContainerOpsMetrics(cmdType);
     Container container = getContainer(containerID);
     boolean isWriteStage =
         (cmdType == Type.WriteChunk && dispatcherContext != null
@@ -214,6 +213,16 @@ private ContainerCommandResponseProto dispatchRequest(
             && dispatcherContext.getStage()
             == DispatcherContext.WriteChunkStage.COMMIT_DATA);
 
+    if (dispatcherContext == null) {
+      // increase all op not through ratis
+      metrics.incContainerOpsMetrics(cmdType);
+    } else if (isWriteStage) {
+      // increase WriteChunk in only WRITE_STAGE
+      metrics.incContainerOpsMetrics(cmdType);
+    } else if (cmdType != Type.WriteChunk) {
+      metrics.incContainerOpsMetrics(cmdType);
+    }
+
     try {
       if (DispatcherContext.op(dispatcherContext).validateToken()) {
         validateToken(msg);
diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
index 2d3a0b220ef5..a9f5fc342d65 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/container/metrics/TestContainerMetrics.java
@@ -18,10 +18,13 @@
 package org.apache.hadoop.ozone.container.metrics;
 
 import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
+import org.apache.commons.io.FileUtils;
 import org.apache.hadoop.fs.FileUtil;
 import org.apache.hadoop.hdds.DFSConfigKeysLegacy;
 import org.apache.hadoop.hdds.client.BlockID;
@@ -31,114 +34,178 @@
 import org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos.ContainerCommandResponseProto;
 import org.apache.hadoop.hdds.scm.ScmConfigKeys;
 import org.apache.hadoop.hdds.scm.XceiverClientGrpc;
+import org.apache.hadoop.hdds.scm.XceiverClientRatis;
+import org.apache.hadoop.hdds.scm.XceiverClientSpi;
 import org.apache.hadoop.hdds.scm.pipeline.MockPipeline;
 import org.apache.hadoop.hdds.scm.pipeline.Pipeline;
 import org.apache.hadoop.metrics2.MetricsRecordBuilder;
+import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
 import org.apache.hadoop.ozone.OzoneConfigKeys;
+import org.apache.hadoop.ozone.RatisTestHelper;
 import org.apache.hadoop.ozone.container.ContainerTestHelper;
 import org.apache.hadoop.ozone.container.common.ContainerTestUtils;
 import org.apache.hadoop.ozone.container.common.helpers.ContainerMetrics;
 import org.apache.hadoop.ozone.container.common.impl.ContainerSet;
 import org.apache.hadoop.ozone.container.common.impl.HddsDispatcher;
+import org.apache.hadoop.ozone.container.common.interfaces.ContainerDispatcher;
 import org.apache.hadoop.ozone.container.common.interfaces.Handler;
 import org.apache.hadoop.ozone.container.common.statemachine.StateContext;
 import org.apache.hadoop.ozone.container.common.transport.server.XceiverServerGrpc;
+import org.apache.hadoop.ozone.container.common.transport.server.XceiverServerSpi;
+import org.apache.hadoop.ozone.container.common.transport.server.ratis.XceiverServerRatis;
 import org.apache.hadoop.ozone.container.common.utils.StorageVolumeUtil;
 import org.apache.hadoop.ozone.container.common.volume.HddsVolume;
 import org.apache.hadoop.ozone.container.common.volume.MutableVolumeSet;
 import org.apache.hadoop.ozone.container.common.volume.StorageVolume;
 import org.apache.hadoop.ozone.container.common.volume.VolumeSet;
+import org.apache.hadoop.ozone.container.ozoneimpl.ContainerController;
 import org.apache.ozone.test.GenericTestUtils;
 
 import com.google.common.collect.Maps;
-import static org.apache.hadoop.hdds.protocol.MockDatanodeDetails.randomDatanodeDetails;
-import static org.apache.hadoop.test.MetricsAsserts.assertCounter;
-import static org.apache.hadoop.test.MetricsAsserts.assertQuantileGauges;
-import static org.apache.hadoop.test.MetricsAsserts.getMetrics;
-
-import org.apache.ozone.test.JUnit5AwareTimeout;
-import org.junit.Assert;
-import org.junit.Rule;
+import static org.apache.ozone.test.MetricsAsserts.assertCounter;
+import static org.apache.ozone.test.MetricsAsserts.assertQuantileGauges;
+import static org.apache.ozone.test.MetricsAsserts.getMetrics;
+import static org.apache.ratis.rpc.SupportedRpcType.GRPC;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.apache.ratis.util.function.CheckedBiConsumer;
+import org.apache.ratis.util.function.CheckedBiFunction;
+import org.apache.ratis.util.function.CheckedConsumer;
+import org.apache.ratis.util.function.CheckedFunction;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.junit.rules.TestRule;
-import org.junit.rules.Timeout;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.io.TempDir;
 
 /**
  * Test for metrics published by storage containers.
  */
+@Timeout(300)
 public class TestContainerMetrics {
+  static final String TEST_DIR = GenericTestUtils.getRandomizedTempPath() + File.separator;
+  @TempDir
+  private Path tempDir;
+  private static final OzoneConfiguration CONF = new OzoneConfiguration();
+  private static final int DFS_METRICS_PERCENTILES_INTERVALS = 1;
+
+  @BeforeAll
+  public static void setup() {
+    DefaultMetricsSystem.setMiniClusterMode(true);
+    CONF.setInt(DFSConfigKeysLegacy.DFS_METRICS_PERCENTILES_INTERVALS_KEY,
+        DFS_METRICS_PERCENTILES_INTERVALS);
+    CONF.setBoolean(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATASTREAM_ENABLED, false);
+    CONF.set(OzoneConfigKeys.OZONE_METADATA_DIRS, TEST_DIR);
+
+  }
+
+  @AfterAll
+  public static void cleanup() {
+    // clean up volume dir
+    File file = new File(TEST_DIR);
+    if (file.exists()) {
+      FileUtil.fullyDelete(file);
+    }
+  }
 
-  /**
-    * Set a timeout for each test.
-    */
-  @Rule
-  public TestRule timeout = new JUnit5AwareTimeout(Timeout.seconds(300));
+  @AfterEach
+  public void cleanUp() throws IOException {
+    FileUtils.deleteQuietly(new File(CONF.get(ScmConfigKeys.HDDS_DATANODE_DIR_KEY)));
+    FileUtils.deleteQuietly(CONF.get(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR) == null ?
+        null : new File(CONF.get(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR)));
+  }
 
   @Test
   public void testContainerMetrics() throws Exception {
-    XceiverServerGrpc server = null;
-    XceiverClientGrpc client = null;
-    long containerID = ContainerTestHelper.getTestContainerID();
-    String path = GenericTestUtils.getRandomizedTempPath();
+    runTestClientServer(pipeline -> CONF
+            .setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
+                pipeline.getFirstNode()
+                    .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue()),
+        pipeline -> new XceiverClientGrpc(pipeline, CONF),
+        (dn, volumeSet) -> new XceiverServerGrpc(dn, CONF,
+            createDispatcher(dn, volumeSet), null), (dn, p) -> {
+        });
+  }
 
-    try {
-      final int interval = 1;
-      Pipeline pipeline = MockPipeline
-          .createSingleNodePipeline();
-      OzoneConfiguration conf = new OzoneConfiguration();
-      conf.setInt(OzoneConfigKeys.HDDS_CONTAINER_IPC_PORT,
-          pipeline.getFirstNode()
-              .getPort(DatanodeDetails.Port.Name.STANDALONE).getValue());
-      conf.setInt(DFSConfigKeysLegacy.DFS_METRICS_PERCENTILES_INTERVALS_KEY,
-          interval);
-
-      DatanodeDetails datanodeDetails = randomDatanodeDetails();
-      conf.set(ScmConfigKeys.HDDS_DATANODE_DIR_KEY, path);
-      conf.set(OzoneConfigKeys.OZONE_METADATA_DIRS, path);
-      VolumeSet volumeSet = new MutableVolumeSet(
-          datanodeDetails.getUuidString(), conf,
-          null, StorageVolume.VolumeType.DATA_VOLUME, null);
-      ContainerSet containerSet = new ContainerSet(1000);
-      StateContext context = ContainerTestUtils.getMockContext(
-          datanodeDetails, conf);
-      ContainerMetrics metrics = ContainerMetrics.create(conf);
-      Map<ContainerProtos.ContainerType, Handler> handlers = Maps.newHashMap();
-      for (ContainerProtos.ContainerType containerType :
-          ContainerProtos.ContainerType.values()) {
-        handlers.put(containerType,
-            Handler.getHandlerForContainerType(containerType, conf,
-                context.getParent().getDatanodeDetails().getUuidString(),
-                containerSet, volumeSet, metrics,
-                c -> { }));
-      }
-      HddsDispatcher dispatcher = new HddsDispatcher(conf, containerSet,
+  @Test
+  public void testContainerMetricsRatis() throws Exception {
+    runTestClientServer(
+        pipeline -> RatisTestHelper.initRatisConf(GRPC, CONF),
+        pipeline -> XceiverClientRatis.newXceiverClientRatis(pipeline, CONF),
+        this::newXceiverServerRatis, (dn, p) ->
+            RatisTestHelper.initXceiverServerRatis(GRPC, dn, p));
+  }
+
+  private static MutableVolumeSet createVolumeSet(DatanodeDetails dn, String path) throws IOException {
+    CONF.set(ScmConfigKeys.HDDS_DATANODE_DIR_KEY, path);
+    return new MutableVolumeSet(
+        dn.getUuidString(), CONF,
+        null, StorageVolume.VolumeType.DATA_VOLUME, null);
+  }
+
+  private HddsDispatcher createDispatcher(DatanodeDetails dd, VolumeSet volumeSet) {
+    ContainerSet containerSet = new ContainerSet(1000);
+    StateContext context = ContainerTestUtils.getMockContext(
+        dd, CONF);
+    ContainerMetrics metrics = ContainerMetrics.create(CONF);
+    Map<ContainerProtos.ContainerType, Handler> handlers = Maps.newHashMap();
+    for (ContainerProtos.ContainerType containerType :
+        ContainerProtos.ContainerType.values()) {
+      handlers.put(containerType,
+          Handler.getHandlerForContainerType(containerType, CONF,
+              context.getParent().getDatanodeDetails().getUuidString(),
+              containerSet, volumeSet, metrics,
+              c -> { }));
+    }
+    HddsDispatcher dispatcher = new HddsDispatcher(CONF, containerSet,
           volumeSet, handlers, context, metrics, null);
-      dispatcher.setClusterId(UUID.randomUUID().toString());
+    dispatcher.setClusterId(UUID.randomUUID().toString());
+    return dispatcher;
+  }
+
+  static void runTestClientServer(
+      CheckedConsumer<Pipeline, IOException> initConf,
+      CheckedFunction<Pipeline, XceiverClientSpi,
+                      IOException> createClient,
+      CheckedBiFunction<DatanodeDetails, MutableVolumeSet, XceiverServerSpi,
+                IOException> createServer,
+      CheckedBiConsumer<DatanodeDetails, Pipeline, IOException> initServer)
+      throws Exception {
+    XceiverServerSpi server = null;
+    XceiverClientSpi client = null;
+    long containerID = ContainerTestHelper.getTestContainerID();
+    MutableVolumeSet volumeSet = null;
 
-      server = new XceiverServerGrpc(datanodeDetails, conf, dispatcher, null);
-      client = new XceiverClientGrpc(pipeline, conf);
+    try {
+      final Pipeline pipeline =
+          MockPipeline.createSingleNodePipeline();
+      initConf.accept(pipeline);
 
+      DatanodeDetails dn = pipeline.getFirstNode();
+      volumeSet = createVolumeSet(dn, TEST_DIR + dn.getUuidString());
+      server = createServer.apply(dn, volumeSet);
       server.start();
+      initServer.accept(dn, pipeline);
+
+      client = createClient.apply(pipeline);
       client.connect();
 
       // Write Chunk
       BlockID blockID = ContainerTestHelper.getTestBlockID(containerID);
-      ContainerTestHelper.getWriteChunkRequest(
-          pipeline, blockID, 1024);
-      ContainerProtos.ContainerCommandRequestProto writeChunkRequest =
+      final ContainerProtos.ContainerCommandRequestProto writeChunkRequest =
           ContainerTestHelper.getWriteChunkRequest(
               pipeline, blockID, 1024);
-      ContainerCommandResponseProto response =
-              client.sendCommand(writeChunkRequest);
-      Assert.assertEquals(ContainerProtos.Result.SUCCESS,
+      ContainerCommandResponseProto response = client.sendCommand(writeChunkRequest);
+      assertEquals(ContainerProtos.Result.SUCCESS,
           response.getResult());
 
       //Read Chunk
-      ContainerProtos.ContainerCommandRequestProto readChunkRequest =
+      final ContainerProtos.ContainerCommandRequestProto readChunkRequest =
           ContainerTestHelper.getReadChunkRequest(pipeline, writeChunkRequest
               .getWriteChunk());
       response = client.sendCommand(readChunkRequest);
-      Assert.assertEquals(ContainerProtos.Result.SUCCESS, response.getResult());
+      assertEquals(ContainerProtos.Result.SUCCESS, response.getResult());
 
       MetricsRecordBuilder containerMetrics = getMetrics(
           "StorageContainerMetrics");
@@ -149,11 +216,10 @@ public void testContainerMetrics() throws Exception {
       assertCounter("bytesWriteChunk", 1024L, containerMetrics);
       assertCounter("bytesReadChunk", 1024L, containerMetrics);
 
-      String sec = interval + "s";
-      Thread.sleep((interval + 1) * 1000);
+      String sec = DFS_METRICS_PERCENTILES_INTERVALS + "s";
+      Thread.sleep((DFS_METRICS_PERCENTILES_INTERVALS + 1) * 1000);
       assertQuantileGauges("WriteChunkNanos" + sec, containerMetrics);
 
-      // Check VolumeIOStats metrics
       List<HddsVolume> volumes =
           StorageVolumeUtil.getHddsVolumesList(volumeSet.getVolumesList());
       HddsVolume hddsVolume = volumes.get(0);
@@ -163,19 +229,30 @@ public void testContainerMetrics() throws Exception {
       assertCounter("ReadOpCount", 1L, volumeIOMetrics);
       assertCounter("WriteBytes", 1024L, volumeIOMetrics);
       assertCounter("WriteOpCount", 1L, volumeIOMetrics);
-
     } finally {
+      ContainerMetrics.remove();
+      if (volumeSet != null) {
+        volumeSet.shutdown();
+      }
       if (client != null) {
         client.close();
       }
       if (server != null) {
         server.stop();
       }
-      // clean up volume dir
-      File file = new File(path);
-      if (file.exists()) {
-        FileUtil.fullyDelete(file);
-      }
     }
   }
+
+  private XceiverServerSpi newXceiverServerRatis(DatanodeDetails dn, MutableVolumeSet volumeSet)
+      throws IOException {
+    CONF.setInt(OzoneConfigKeys.HDDS_CONTAINER_RATIS_IPC_PORT,
+        dn.getPort(DatanodeDetails.Port.Name.RATIS).getValue());
+    final String dir = TEST_DIR + dn.getUuid();
+    CONF.set(OzoneConfigKeys.HDDS_CONTAINER_RATIS_DATANODE_STORAGE_DIR, dir);
+    final ContainerDispatcher dispatcher = createDispatcher(dn,
+        volumeSet);
+    return XceiverServerRatis.newXceiverServerRatis(dn, CONF, dispatcher,
+        new ContainerController(new ContainerSet(1000), Maps.newHashMap()),
+        null, null);
+  }
 }

From e2da49cdcbddfc685a8d2c8cf6a12f2cf79438fb Mon Sep 17 00:00:00 2001
From: Arafat2198 <arafatp126@gmail.com>
Date: Mon, 22 Jul 2024 14:14:06 +0530
Subject: [PATCH 7/9] HDDS-11187. Fix Event Handling in Recon
 OMDBUpdatesHandler to Prevent ClassCastException. (#6950)

(cherry picked from commit 86c433919ea8252763a534bb0bf17f5b4c57b86f)
---
 .../ozone/recon/tasks/OMDBUpdatesHandler.java | 11 +--
 .../recon/tasks/TestOMDBUpdatesHandler.java   | 67 +++++++++++++++++++
 2 files changed, 74 insertions(+), 4 deletions(-)

diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/tasks/OMDBUpdatesHandler.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/tasks/OMDBUpdatesHandler.java
index cfaf4bb60a8f..41e6bf962a7e 100644
--- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/tasks/OMDBUpdatesHandler.java
+++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/tasks/OMDBUpdatesHandler.java
@@ -48,8 +48,7 @@ public class OMDBUpdatesHandler extends ManagedWriteBatch.Handler {
   private Map<Integer, String> tablesNames;
   private OMMetadataManager omMetadataManager;
   private List<OMDBUpdateEvent> omdbUpdateEvents = new ArrayList<>();
-  private Map<Object, OMDBUpdateEvent> omdbLatestUpdateEvents
-      = new HashMap<>();
+  private Map<String, Map<Object, OMDBUpdateEvent>> omdbLatestUpdateEvents = new HashMap<>();
   private OMDBDefinition omdbDefinition;
   private OmUpdateEventValidator omUpdateEventValidator;
 
@@ -112,6 +111,10 @@ private void processEvent(int cfIndex, byte[] keyBytes, byte[]
       final Object key = cf.getKeyCodec().fromPersistedFormat(keyBytes);
       builder.setKey(key);
 
+      // Initialize table-specific event map if it does not exist
+      omdbLatestUpdateEvents.putIfAbsent(tableName, new HashMap<>());
+      Map<Object, OMDBUpdateEvent> tableEventsMap = omdbLatestUpdateEvents.get(tableName);
+
       // Handle the event based on its type:
       // - PUT with a new key: Insert the new value.
       // - PUT with an existing key: Update the existing value.
@@ -120,7 +123,7 @@ private void processEvent(int cfIndex, byte[] keyBytes, byte[]
       // necessary.
       Table table = omMetadataManager.getTable(tableName);
 
-      OMDBUpdateEvent latestEvent = omdbLatestUpdateEvents.get(key);
+      OMDBUpdateEvent latestEvent = tableEventsMap.get(key);
       Object oldValue;
       if (latestEvent != null) {
         oldValue = latestEvent.getValue();
@@ -184,7 +187,7 @@ private void processEvent(int cfIndex, byte[] keyBytes, byte[]
                 "action = %s", tableName, action));
       }
       omdbUpdateEvents.add(event);
-      omdbLatestUpdateEvents.put(key, event);
+      tableEventsMap.put(key, event);
     } else {
       // Log and ignore events if key or value types are undetermined.
       if (LOG.isWarnEnabled()) {
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestOMDBUpdatesHandler.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestOMDBUpdatesHandler.java
index dca0da341a2d..9ca8004bcde7 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestOMDBUpdatesHandler.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestOMDBUpdatesHandler.java
@@ -42,6 +42,8 @@
 import org.apache.hadoop.ozone.om.OMMetadataManager;
 import org.apache.hadoop.ozone.om.OmMetadataManagerImpl;
 import org.apache.hadoop.ozone.om.codec.OMDBDefinition;
+import org.apache.hadoop.ozone.om.helpers.RepeatedOmKeyInfo;
+import org.apache.hadoop.ozone.om.helpers.OmDirectoryInfo;
 import org.apache.hadoop.ozone.om.helpers.BucketLayout;
 import org.apache.hadoop.ozone.om.helpers.OmBucketInfo;
 import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
@@ -286,6 +288,71 @@ public void testOperateOnSameEntry() throws Exception {
         ((OmKeyInfo)keyPut2.getOldValue()).getKeyName());
   }
 
+  /**
+   * Test to verify that events with duplicate keys in different tables
+   * (FileTable and DirectoryTable) are handled correctly without causing
+   * ClassCastException or event conflicts.
+   *
+   * This test simulates creating a file, deleting the file, and then creating
+   * a directory with the same name under the same parent ID in different tables.
+   * It ensures that the events are correctly processed and stored in the
+   * `omdbLatestUpdateEvents` map without causing any type mismatches or
+   * exceptions.
+   *
+   * @throws Exception if any error occurs during the test execution.
+   */
+  @Test
+  public void testEventsHavingDuplicateRocksDBKey() throws Exception {
+    // Step 1: Create a file with the name "sameName" in the fileTable
+    OmKeyInfo fileKeyInfo = getOmKeyInfo("sampleVol", "bucketOne", "sameName");
+    omMetadataManager.getFileTable().put("/sampleVol/bucketOne/parentId/sameName", fileKeyInfo);
+
+    // Step 2: Delete the file by adding its information to the deletedTable
+    RepeatedOmKeyInfo repeatedKeyInfo = new RepeatedOmKeyInfo(fileKeyInfo);
+    omMetadataManager.getDeletedTable().put("/sampleVol/bucketOne/parentId/sameName", repeatedKeyInfo);
+
+    // Step 3: Create a directory with the same name "sameName" in the directoryTable
+    OmDirectoryInfo dirInfo = OmDirectoryInfo.newBuilder()
+        .setName("sameName")
+        .setParentObjectID(fileKeyInfo.getParentObjectID())
+        .setObjectID(fileKeyInfo.getObjectID())
+        .setCreationTime(System.currentTimeMillis())
+        .setModificationTime(System.currentTimeMillis())
+        .build();
+    omMetadataManager.getDirectoryTable().put("/sampleVol/bucketOne/parentId/sameName", dirInfo);
+
+    // Capture the events from the OM Metadata Manager
+    List<byte[]> writeBatches = getBytesFromOmMetaManager(0);
+    OMDBUpdatesHandler omdbUpdatesHandler = captureEvents(writeBatches);
+
+    // Retrieve the captured events and assert the correct number of events
+    List<OMDBUpdateEvent> events = omdbUpdatesHandler.getEvents();
+    // Verify no events were discarded
+    assertEquals(3, events.size());
+
+    // Validate the file creation event
+    OMDBUpdateEvent filePutEvent = events.get(0);
+    assertEquals(PUT, filePutEvent.getAction());
+    assertEquals("/sampleVol/bucketOne/parentId/sameName", filePutEvent.getKey());
+    assertEquals("sameName", ((OmKeyInfo) filePutEvent.getValue()).getKeyName());
+    assertNull(filePutEvent.getOldValue());
+
+    // Validate the file deletion event
+    OMDBUpdateEvent fileDeleteEvent = events.get(1);
+    assertEquals(PUT, fileDeleteEvent.getAction());
+    assertEquals("/sampleVol/bucketOne/parentId/sameName", fileDeleteEvent.getKey());
+    assertEquals("sameName",
+        ((RepeatedOmKeyInfo) fileDeleteEvent.getValue()).getOmKeyInfoList().get(0).getKeyName());
+
+    // Validate the directory creation event
+    OMDBUpdateEvent dirPutEvent = events.get(2);
+    assertEquals(PUT, dirPutEvent.getAction());
+    assertEquals("/sampleVol/bucketOne/parentId/sameName", dirPutEvent.getKey());
+    assertEquals("sameName", ((OmDirectoryInfo) dirPutEvent.getValue()).getName());
+    // There will be no old value as the key was not present in the directoryTable before
+    assertNull(dirPutEvent.getOldValue());
+  }
+
   @Test
   public void testGetKeyType() throws IOException {
     final String keyTable = omMetadataManager

From f82b0198f07fae73ecf222ca2366f442cbce08e3 Mon Sep 17 00:00:00 2001
From: Sumit Agrawal <sumit.jecrc@gmail.com>
Date: Wed, 24 Jul 2024 15:34:49 +0800
Subject: [PATCH 8/9] HDDS-11215. Quota count can go wrong when double buffer
 flush takes time. (#6978)

(cherry picked from commit 19f9afb42a1becfc6fefcf725374db08d42c3bc7)
---
 .../TestDirectoryDeletingServiceWithFSO.java  | 82 +++++++++++++++++++
 .../hadoop/ozone/om/KeyManagerImpl.java       |  6 ++
 .../om/ratis/OzoneManagerDoubleBuffer.java    |  4 +-
 .../key/OMDirectoriesPurgeRequestWithFSO.java | 12 ++-
 4 files changed, 101 insertions(+), 3 deletions(-)

diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestDirectoryDeletingServiceWithFSO.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestDirectoryDeletingServiceWithFSO.java
index d5c042bb036a..cc89dafd9d96 100644
--- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestDirectoryDeletingServiceWithFSO.java
+++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestDirectoryDeletingServiceWithFSO.java
@@ -18,6 +18,7 @@
 
 package org.apache.hadoop.fs.ozone;
 
+import java.util.concurrent.CompletableFuture;
 import org.apache.hadoop.fs.CommonConfigurationKeysPublic;
 import org.apache.hadoop.fs.FSDataOutputStream;
 import org.apache.hadoop.fs.FileStatus;
@@ -33,8 +34,13 @@
 import org.apache.hadoop.ozone.TestDataUtil;
 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.OMMetadataManager;
+import org.apache.hadoop.ozone.om.helpers.OzoneFileStatus;
 import org.apache.hadoop.ozone.om.helpers.SnapshotInfo;
+import org.apache.hadoop.ozone.om.ratis.OzoneManagerDoubleBuffer;
+import org.apache.hadoop.ozone.om.ratis.OzoneManagerStateMachine;
+import org.apache.hadoop.ozone.om.request.file.OMFileRequest;
 import org.apache.hadoop.ozone.om.service.DirectoryDeletingService;
 import org.apache.hadoop.ozone.om.service.KeyDeletingService;
 import org.apache.hadoop.ozone.om.OMConfigKeys;
@@ -58,6 +64,7 @@
 import java.util.function.LongSupplier;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_ACL_ENABLED;
@@ -298,6 +305,81 @@ public void testDeleteWithMultiLevels() throws Exception {
     assertTrue(dirDeletingService.getRunCount().get() > 1);
   }
 
+  @Test
+  public void testDeleteWithMultiLevelsBlockDoubleBuffer() throws Exception {
+    Path root = new Path("/rootDirdd");
+    Path appRoot = new Path(root, "appRoot");
+
+    for (int i = 1; i <= 3; i++) {
+      Path parent = new Path(appRoot, "parentDir" + i);
+      Path child = new Path(parent, "childFile");
+      ContractTestUtils.touch(fs, child);
+    }
+
+    OMMetadataManager metadataManager = cluster.getOzoneManager().getMetadataManager();
+    Table<String, OmKeyInfo> deletedDirTable = metadataManager.getDeletedDirTable();
+    Table<String, OmKeyInfo> keyTable = metadataManager.getKeyTable(getFSOBucketLayout());
+    Table<String, OmDirectoryInfo> dirTable = metadataManager.getDirectoryTable();
+
+    DirectoryDeletingService dirDeletingService = (DirectoryDeletingService) cluster.getOzoneManager().getKeyManager()
+            .getDirDeletingService();
+
+    // Before delete
+    assertTableRowCount(deletedDirTable, 0);
+    assertTableRowCount(dirTable, 5);
+    assertTableRowCount(keyTable, 3);
+
+    // stop daemon to simulate blocked double buffer
+    OzoneManagerStateMachine omStateMachine = cluster.getOzoneManager().getOmRatisServer().getOmStateMachine();
+    OzoneManagerDoubleBuffer omDoubleBuffer = omStateMachine.getOzoneManagerDoubleBuffer();
+    omDoubleBuffer.awaitFlush();
+    omDoubleBuffer.stopDaemon();
+
+    OzoneVolume volume = client.getObjectStore().getVolume(volumeName);
+    OzoneBucket bucket = volume.getBucket(bucketName);    long volumeId = metadataManager.getVolumeId(volumeName);
+
+    // manually delete dir and add to deleted table. namespace count occupied "1" as manual deletion do not reduce
+    long bucketId = metadataManager.getBucketId(volumeName, bucketName);
+    OzoneFileStatus keyStatus = OMFileRequest.getOMKeyInfoIfExists(
+        metadataManager, volumeName, bucketName, "rootDirdd", 0,
+        cluster.getOzoneManager().getDefaultReplicationConfig());
+    assertNotNull(keyStatus);
+    String ozoneDbKey = metadataManager.getOzonePathKey(volumeId, bucketId, keyStatus.getKeyInfo().getParentObjectID(),
+        keyStatus.getKeyInfo().getFileName());
+    deletedDirTable.put(ozoneDbKey, keyStatus.getKeyInfo());
+    dirTable.delete(ozoneDbKey);
+    assertTableRowCount(deletedDirTable, 1);
+    assertTableRowCount(dirTable, 4);
+
+    System.out.println("starting count: " + bucket.getUsedNamespace());
+
+    // wait for running 2 more iteration
+    long currentCount = dirDeletingService.getRunCount().get();
+    GenericTestUtils.waitFor(() -> dirDeletingService.getRunCount().get() > currentCount + 2, 1000,
+        10000);
+
+    // verify bucket used namespace is not going -ve
+    assertTrue(volume.getBucket(bucketName).getUsedNamespace() >= 0);
+
+    // re-init double buffer in state machine to resume further processing
+    omStateMachine.pause();
+    omStateMachine.unpause(omStateMachine.getLastAppliedTermIndex().getIndex(),
+        omStateMachine.getLatestSnapshot().getIndex());
+    // flush previous pending transaction manually
+    omDoubleBuffer.resume();
+    CompletableFuture.supplyAsync(() -> {
+      omDoubleBuffer.flushTransactions();
+      return null;
+    });
+    omDoubleBuffer.awaitFlush();
+    omDoubleBuffer.stop();
+    // verify deletion progress completion
+    assertTableRowCount(deletedDirTable, 0);
+    assertTableRowCount(keyTable, 0);
+    assertTrue(volume.getBucket(bucketName).getUsedNamespace() >= 0);
+    assertTrue(volume.getBucket(bucketName).getUsedBytes() == 0);
+  }
+
   @Test
   public void testDeleteFilesAndSubFiles() throws Exception {
 
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java
index fdfb2e12a0e4..6c9debd9febd 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/KeyManagerImpl.java
@@ -1990,6 +1990,9 @@ private List<OmKeyInfo> gatherSubDirsWithIterator(OmKeyInfo parentInfo,
           parentInfo.getObjectID())) {
         break;
       }
+      if (!metadataManager.getDirectoryTable().isExist(entry.getKey())) {
+        continue;
+      }
       String dirName = OMFileRequest.getAbsolutePath(parentInfo.getKeyName(),
           dirInfo.getName());
       OmKeyInfo omKeyInfo = OMFileRequest.getOmKeyInfo(
@@ -2024,6 +2027,9 @@ public List<OmKeyInfo> getPendingDeletionSubFiles(long volumeId,
             parentInfo.getObjectID())) {
           break;
         }
+        if (!metadataManager.getFileTable().isExist(entry.getKey())) {
+          continue;
+        }
         fileInfo.setFileName(fileInfo.getKeyName());
         String fullKeyPath = OMFileRequest.getAbsolutePath(
             parentInfo.getKeyName(), fileInfo.getKeyName());
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/OzoneManagerDoubleBuffer.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/OzoneManagerDoubleBuffer.java
index 3e59a52bda66..d721d9d209da 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/OzoneManagerDoubleBuffer.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ratis/OzoneManagerDoubleBuffer.java
@@ -294,7 +294,7 @@ private void addToBatchTransactionInfoWithTrace(String parentName,
    * and commit to DB.
    */
   @VisibleForTesting
-  void flushTransactions() {
+  public void flushTransactions() {
     while (isRunning.get() && canFlush()) {
       flushCurrentBuffer();
     }
@@ -698,7 +698,7 @@ int getReadyBufferSize() {
   }
 
   @VisibleForTesting
-  void resume() {
+  public void resume() {
     isRunning.set(true);
   }
 
diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/OMDirectoriesPurgeRequestWithFSO.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/OMDirectoriesPurgeRequestWithFSO.java
index 474a100f9e39..33708450294a 100644
--- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/OMDirectoriesPurgeRequestWithFSO.java
+++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/request/key/OMDirectoriesPurgeRequestWithFSO.java
@@ -24,6 +24,8 @@
 import java.util.Map;
 import java.util.Set;
 import org.apache.commons.lang3.tuple.Pair;
+import org.apache.hadoop.hdds.utils.db.cache.CacheKey;
+import org.apache.hadoop.hdds.utils.db.cache.CacheValue;
 import org.apache.hadoop.ozone.om.OMMetadataManager;
 import org.apache.hadoop.ozone.om.OzoneManager;
 import org.apache.hadoop.ozone.om.helpers.BucketLayout;
@@ -84,7 +86,7 @@ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
                 volumeName, bucketName);
             lockSet.add(volBucketPair);
           }
-          
+
           OmBucketInfo omBucketInfo = getBucketInfo(omMetadataManager,
               volumeName, bucketName);
           // bucketInfo can be null in case of delete volume or bucket
@@ -92,6 +94,10 @@ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
           if (null != omBucketInfo
               && omBucketInfo.getObjectID() == path.getBucketId()) {
             omBucketInfo.incrUsedNamespace(-1L);
+            String ozoneDbKey = omMetadataManager.getOzonePathKey(path.getVolumeId(),
+                path.getBucketId(), keyInfo.getParentObjectID(), keyInfo.getFileName());
+            omMetadataManager.getDirectoryTable().addCacheEntry(new CacheKey<>(ozoneDbKey),
+                CacheValue.get(trxnLogIndex));
             volBucketInfoMap.putIfAbsent(volBucketPair, omBucketInfo);
           }
         }
@@ -115,6 +121,10 @@ public OMClientResponse validateAndUpdateCache(OzoneManager ozoneManager,
               && omBucketInfo.getObjectID() == path.getBucketId()) {
             omBucketInfo.incrUsedBytes(-sumBlockLengths(keyInfo));
             omBucketInfo.incrUsedNamespace(-1L);
+            String ozoneDbKey = omMetadataManager.getOzonePathKey(path.getVolumeId(),
+                path.getBucketId(), keyInfo.getParentObjectID(), keyInfo.getFileName());
+            omMetadataManager.getFileTable().addCacheEntry(new CacheKey<>(ozoneDbKey),
+                CacheValue.get(trxnLogIndex));
             volBucketInfoMap.putIfAbsent(volBucketPair, omBucketInfo);
           }
         }

From f5cd2ec2e26ebd838604c7b2c059a37bc7a761e3 Mon Sep 17 00:00:00 2001
From: Smita <112169209+smitajoshi12@users.noreply.github.com>
Date: Thu, 25 Jul 2024 20:13:10 +0800
Subject: [PATCH 9/9] HDDS-11140. Recon Disk Usage Metadata Details are not
 working for du api (#6966)

(cherry picked from commit 96e1a8c44654280f779c28fba2c7d4a519860c4c)
---
 .../resources/webapps/recon/ozone-recon-web/api/db.json  | 9 +++++++++
 .../webapps/recon/ozone-recon-web/api/routes.json        | 1 +
 .../ozone-recon-web/src/views/diskUsage/diskUsage.tsx    | 4 +---
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/db.json b/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/db.json
index 204609f66fec..c1167266f412 100644
--- a/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/db.json
+++ b/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/db.json
@@ -1806,6 +1806,15 @@
     ],
     "sizeDirectKey": 0
   },
+  "replica": {
+    "status": "OK",
+    "path": "/s3v/fso-bucket/dir1/key1-fso",
+    "size": 17289,
+    "sizeWithReplica": 17289,
+    "subPathCount": 0,
+    "subPaths": [],
+    "sizeDirectKey": -1
+  },
   "taskStatus": [
     {
       "taskName": "ContainerKeyMapperTask",
diff --git a/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/routes.json b/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/routes.json
index 0bf0c69f5459..11bcfd7e06a9 100644
--- a/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/routes.json
+++ b/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/api/routes.json
@@ -21,6 +21,7 @@
   "/namespace/du?path=/dummyVolume/dummyBucket/key:id*": "/key",
   "/namespace/du?path=/vol1/bucket1/empty&files=true": "/empty",
   "/namespace/du?path=/clunky&files=true": "/clunky",
+  "/namespace/du?path=/*&replica=true": "/replica",
   "/namespace/summary?path=*": "/metadata",
   "/namespace/quota?path=*": "/quota",
   "/task/status": "/taskStatus",
diff --git a/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/src/views/diskUsage/diskUsage.tsx b/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/src/views/diskUsage/diskUsage.tsx
index 0dbf418a5867..d71abc25a4d8 100644
--- a/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/src/views/diskUsage/diskUsage.tsx
+++ b/hadoop-ozone/recon/src/main/resources/webapps/recon/ozone-recon-web/src/views/diskUsage/diskUsage.tsx
@@ -295,7 +295,7 @@ export class DiskUsage extends React.Component<Record<string, object>, IDUState>
       keys.push('Entity Type');
       values.push(summaryResponse.type);
 
-      if (summaryResponse.countStats.type === 'KEY') {
+      if (summaryResponse.type === 'KEY') {
         const keyEndpoint = `/api/v1/namespace/du?path=${path}&replica=true`;
         const { request: metadataRequest, controller: metadataNewController } = AxiosGetHelper(keyEndpoint, cancelKeyMetadataSignal);
         cancelKeyMetadataSignal = metadataNewController;
@@ -304,8 +304,6 @@ export class DiskUsage extends React.Component<Record<string, object>, IDUState>
           values.push(byteToSize(response.data.size, 3));
           keys.push('File Size With Replication');
           values.push(byteToSize(response.data.sizeWithReplica, 3));
-          console.log(values);
-
           this.setState({
             showPanel: true,
             panelKeys: keys,