HDDS-10608. Recon can't get full key when using Recon API.

hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/recon/TestReconContainerEndpoint.java

@@ -0,0 +1,225 @@
+/*
+ * 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.ozone.recon;
+
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
+import org.apache.hadoop.ozone.MiniOzoneCluster;
+import org.apache.hadoop.ozone.client.BucketArgs;
+import org.apache.hadoop.ozone.client.ObjectStore;
+import org.apache.hadoop.ozone.client.OzoneClient;
+import org.apache.hadoop.ozone.client.OzoneVolume;
+import org.apache.hadoop.ozone.client.io.OzoneOutputStream;
+import org.apache.hadoop.ozone.om.OMConfigKeys;
+import org.apache.hadoop.ozone.om.helpers.BucketLayout;
+import org.apache.hadoop.ozone.om.helpers.OmBucketInfo;
+import org.apache.hadoop.ozone.recon.api.ContainerEndpoint;
+import org.apache.hadoop.ozone.recon.api.types.KeyMetadata;
+import org.apache.hadoop.ozone.recon.api.types.KeysResponse;
+import org.apache.hadoop.ozone.recon.persistence.ContainerHealthSchemaManager;
+import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
+import org.apache.hadoop.ozone.recon.scm.ReconContainerManager;
+import java.nio.charset.StandardCharsets;
+import org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestReconContainerEndpoint {
+
+  private static OzoneClient client;
+  private static MiniOzoneCluster cluster = null;
+  private static OzoneConfiguration conf;
+  private static ObjectStore store;
+
+  @BeforeAll
+  public static void init() throws Exception {
+    conf = new OzoneConfiguration();
+    conf.set(OMConfigKeys.OZONE_DEFAULT_BUCKET_LAYOUT,
+        OMConfigKeys.OZONE_BUCKET_LAYOUT_FILE_SYSTEM_OPTIMIZED);
+    cluster = MiniOzoneCluster.newBuilder(conf)
+        .setNumDatanodes(3)
+        .includeRecon(true)
+        .build();
+    cluster.waitForClusterToBeReady();
+    client = cluster.newClient();
+    store = client.getObjectStore();
+  }
+
+  @AfterAll
+  public static void shutdown() throws IOException {
+    if (client != null) {
+      client.close();
+    }
+    if (cluster != null) {
+      cluster.shutdown();
+    }
+  }
+
+  @Test
+  public void testContainerEndpointForFSOLayout() throws Exception {
+    // Setup: Create multiple volumes, buckets, and key hierarchies
+    String volName = "testvol";
+    String bucketName = "fsobucket";
+    // Scenario 1: Deeply nested directories
+    String nestedDirKey = "dir1/dir2/dir3/file1";
+    // Scenario 2: Single file in a bucket
+    String singleFileKey = "file1";
+
+    // Create volume and bucket
+    store.createVolume(volName);
+    OzoneVolume volume = store.getVolume(volName);
+    volume.createBucket(bucketName, BucketArgs.newBuilder()
+        .setBucketLayout(BucketLayout.FILE_SYSTEM_OPTIMIZED).build());
+
+    // Write keys to the bucket
+    writeTestData(volName, bucketName, nestedDirKey, "data1");
+    writeTestData(volName, bucketName, singleFileKey, "data2");
+
+    // Synchronize data from OM to Recon
+    OzoneManagerServiceProviderImpl impl = (OzoneManagerServiceProviderImpl)
+        cluster.getReconServer().getOzoneManagerServiceProvider();
+    impl.syncDataFromOM();
+
+    //Search for the bucket from the bucket table and verify its FSO
+    String buckKey = "/" + volName + "/" + bucketName;
+    OmBucketInfo bucketInfo =
+        cluster.getReconServer().getOzoneManagerServiceProvider()
+            .getOMMetadataManagerInstance().getBucketTable().get(buckKey);
+    assertNotNull(bucketInfo);
+    assertEquals(BucketLayout.FILE_SYSTEM_OPTIMIZED,
+        bucketInfo.getBucketLayout());
+
+    // Assuming a known container ID that these keys have been written into
+    long testContainerID = 1L;
+
+    // Query the ContainerEndpoint for the keys in the specified container
+    Response response = getContainerEndpointResponse(testContainerID);
+
+    assertNotNull(response, "Response should not be null.");
+    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus(),
+        "Expected HTTP 200 OK response.");
+
+    KeysResponse data = (KeysResponse) response.getEntity();
+    Collection<KeyMetadata> keyMetadataList = data.getKeys();
+
+    assertEquals(1, data.getTotalCount());
+    assertEquals(1, keyMetadataList.size());
+
+    // Assert the file name and the complete path.
+    KeyMetadata keyMetadata = keyMetadataList.iterator().next();
+    assertEquals("file1", keyMetadata.getKey());
+    assertEquals("testvol/testbucket/dir1/dir2/dir3/file1",
+        keyMetadata.getCompletePath());
+
+    testContainerID = 2L;
+    response = getContainerEndpointResponse(testContainerID);
+    data = (KeysResponse) response.getEntity();
+    keyMetadataList = data.getKeys();
+    assertEquals(1, data.getTotalCount());
+    assertEquals(1, keyMetadataList.size());
+
+    // Assert the file name and the complete path.
+    keyMetadata = keyMetadataList.iterator().next();
+    assertEquals("file1", keyMetadata.getKey());
+    assertEquals("testvol/testbucket/file1", keyMetadata.getCompletePath());
+  }
+
+  @Test
+  public void testContainerEndpointForOBSBucket() throws Exception {
+    String volumeName = "testvol";
+    String obsBucketName = "obsbucket";
+    String obsSingleFileKey = "file1";
+
+    // Setup volume and OBS bucket
+    store.createVolume(volumeName);
+    OzoneVolume volume = store.getVolume(volumeName);
+    volume.createBucket(obsBucketName,
+        BucketArgs.newBuilder().setBucketLayout(BucketLayout.OBJECT_STORE)
+            .build());
+
+    // Write a single file to the OBS bucket
+    writeTestData(volumeName, obsBucketName, obsSingleFileKey, "Hello OBS!");
+
+    OzoneManagerServiceProviderImpl impl =
+        (OzoneManagerServiceProviderImpl) cluster.getReconServer()
+            .getOzoneManagerServiceProvider();
+    impl.syncDataFromOM();
+
+    // Search for the bucket from the bucket table and verify its OBS
+    String bucketKey = "/" + volumeName + "/" + obsBucketName;
+    OmBucketInfo bucketInfo =
+        cluster.getReconServer().getOzoneManagerServiceProvider()
+            .getOMMetadataManagerInstance().getBucketTable().get(bucketKey);
+    assertNotNull(bucketInfo);
+    assertEquals(BucketLayout.OBJECT_STORE, bucketInfo.getBucketLayout());
+
+    // Initialize the ContainerEndpoint
+    long containerId = 1L;
+    Response response = getContainerEndpointResponse(containerId);
+
+    assertNotNull(response, "Response should not be null.");
+    assertEquals(Response.Status.OK.getStatusCode(), response.getStatus(),
+        "Expected HTTP 200 OK response.");
+    KeysResponse data = (KeysResponse) response.getEntity();
+    Collection<KeyMetadata> keyMetadataList = data.getKeys();
+
+    assertEquals(1, data.getTotalCount());
+    assertEquals(1, keyMetadataList.size());
+
+    KeyMetadata keyMetadata = keyMetadataList.iterator().next();
+    assertEquals("file1", keyMetadata.getKey());
+    assertEquals("testvol/obsbucket/file1", keyMetadata.getCompletePath());
+  }
+
+  private Response getContainerEndpointResponse(long containerId) {
+    OzoneStorageContainerManager reconSCM =
+        cluster.getReconServer().getReconStorageContainerManager();
+    ReconContainerManager reconContainerManager =
+        (ReconContainerManager) reconSCM.getContainerManager();
+    ContainerHealthSchemaManager containerHealthSchemaManager =
+        reconContainerManager.getContainerSchemaManager();
+    ReconOMMetadataManager omMetadataManagerInstance =
+        (ReconOMMetadataManager)
+            cluster.getReconServer().getOzoneManagerServiceProvider()
+                .getOMMetadataManagerInstance();
+    ContainerEndpoint containerEndpoint =
+        new ContainerEndpoint(reconSCM, containerHealthSchemaManager,
+            cluster.getReconServer().getReconNamespaceSummaryManager(),
+            cluster.getReconServer().getReconContainerMetadataManager(),
+            omMetadataManagerInstance);
+    return containerEndpoint.getKeysForContainer(containerId, 10, "");
+  }
+
+  private void writeTestData(String volumeName, String bucketName,
+                             String keyPath, String data) throws Exception {
+    try (OzoneOutputStream out = client.getObjectStore().getVolume(volumeName)
+        .getBucket(bucketName)
+        .createKey(keyPath, data.length())) {
+      out.write(data.getBytes(StandardCharsets.UTF_8));
+    }
+  }
+
+}

hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconUtils.java

@@ -24,6 +24,7 @@
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.nio.file.Path;
@@ -32,6 +33,8 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
 
 import com.google.common.base.Preconditions;
@@ -55,13 +58,19 @@
 import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_EVENT_THREAD_POOL_SIZE_DEFAULT;
 import static org.apache.hadoop.hdds.server.ServerUtils.getDirectoryFromConfig;
 import static org.apache.hadoop.hdds.server.ServerUtils.getOzoneMetaDirPath;
+import static org.apache.hadoop.ozone.OzoneConsts.OM_KEY_PREFIX;
 import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_SCM_DB_DIR;
 import static org.jooq.impl.DSL.currentTimestamp;
 import static org.jooq.impl.DSL.select;
 import static org.jooq.impl.DSL.using;
 
+import org.apache.hadoop.ozone.OmUtils;
+import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
+import org.apache.hadoop.ozone.recon.api.types.NSSummary;
 import org.apache.hadoop.ozone.recon.api.types.DUResponse;
+import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
 import org.apache.hadoop.ozone.recon.scm.ReconContainerReportQueue;
+import org.apache.hadoop.ozone.recon.spi.ReconNamespaceSummaryManager;
 import org.apache.hadoop.security.authentication.client.AuthenticationException;
 import org.hadoop.ozone.recon.schema.tables.daos.GlobalStatsDao;
 import org.hadoop.ozone.recon.schema.tables.pojos.GlobalStats;
@@ -83,6 +92,8 @@ public ReconUtils() {
 
   private static final Logger LOG = LoggerFactory.getLogger(
       ReconUtils.class);
+  private static volatile boolean rebuildTriggered = false;
+  private static volatile boolean isRebuilding = false;
 
   public static File getReconScmDbDir(ConfigurationSource conf) {
     return new ReconUtils().getReconDbDir(conf, OZONE_RECON_SCM_DB_DIR);
@@ -246,25 +257,106 @@ public void untarCheckpointFile(File tarFile, Path destPath)
     }
   }
 
+
+  /**
+   * Constructs the full path of a key from its OmKeyInfo using a bottom-up approach, starting from the leaf node.
+   *
+   * The method begins with the leaf node (the key itself) and recursively prepends parent directory names, fetched
+   * via NSSummary objects, until reaching the parent bucket (parentId is -1). It effectively builds the path from
+   * bottom to top, finally prepending the volume and bucket names to complete the full path. If the directory structure
+   * is currently being rebuilt (indicated by the isRebuilding flag), this method returns an empty string to signify
+   * that path construction is temporarily unavailable.
+   *
+   * @param omKeyInfo The OmKeyInfo object for the key
+   * @return The constructed full path of the key as a String, or an empty string if a rebuild is in progress and
+   *         the path cannot be constructed at this time.
+   * @throws IOException
+   */
+
+  public static String constructFullPath(OmKeyInfo omKeyInfo,
+                                         ReconNamespaceSummaryManager reconNamespaceSummaryManager,
+                                         ReconOMMetadataManager omMetadataManager)
+      throws IOException {
+
+    // Return empty string to signify that path construction is temporarily unavailable
+    if (isRebuilding) {
+      return "";
+    }
+
+    StringBuilder fullPath = new StringBuilder(omKeyInfo.getKeyName());
+    long parentId = omKeyInfo.getParentObjectID();
+    boolean isDirectoryPresent = false;
+
+    while (parentId != 0) {
+      NSSummary nsSummary = reconNamespaceSummaryManager.getNSSummary(parentId);
+      if (nsSummary == null) {
+        break;
+      }
+      if (nsSummary.getParentId() == -1 && !rebuildTriggered) {
+        synchronized (ReconUtils.class) {
+          if (!rebuildTriggered) {
+            triggerRebuild(reconNamespaceSummaryManager, omMetadataManager);
+            rebuildTriggered = true;  // Set the flag to true inside a synchronized block
+          }
+        }
+      }
+      fullPath.insert(0, nsSummary.getDirName() + OM_KEY_PREFIX);
+
+      // Move to the parent ID of the current directory
+      parentId = nsSummary.getParentId();
+      isDirectoryPresent = true;
+    }
+
+    // Prepend the volume and bucket to the constructed path
+    String volumeName = omKeyInfo.getVolumeName();
+    String bucketName = omKeyInfo.getBucketName();
+    fullPath.insert(0, volumeName + OM_KEY_PREFIX + bucketName + OM_KEY_PREFIX);
+    if (isDirectoryPresent) {
+      return OmUtils.normalizeKey(fullPath.toString(), true);
+    }
+    return fullPath.toString();
+  }
+
+  private static void triggerRebuild(ReconNamespaceSummaryManager reconNamespaceSummaryManager,
+                                     ReconOMMetadataManager omMetadataManager) {
+    synchronized (ReconUtils.class) {
+      if (!isRebuilding) {
+        isRebuilding = true;
+        ExecutorService executor = Executors.newSingleThreadExecutor(); // Create the executor
+        executor.submit(() -> {
+          try {
+            reconNamespaceSummaryManager.rebuildNSSummaryTree(omMetadataManager);
+          } finally {
+            isRebuilding = false;
+            rebuildTriggered = false;
+            executor.shutdown(); // Shutdown the executor here
+          }
+        });
+      }
+    }
+  }
+
   /**
    * Make HTTP GET call on the URL and return HttpURLConnection instance.
+   *
    * @param connectionFactory URLConnectionFactory to use.
-   * @param url url to call
-   * @param isSpnego is SPNEGO enabled
+   * @param url               url to call
+   * @param isSpnego          is SPNEGO enabled
    * @return HttpURLConnection instance of the HTTP call.
    * @throws IOException, AuthenticationException While reading the response.
    */
   public HttpURLConnection makeHttpCall(URLConnectionFactory connectionFactory,
-                                  String url, boolean isSpnego)
+                                        String url, boolean isSpnego)
       throws IOException, AuthenticationException {
     HttpURLConnection urlConnection = (HttpURLConnection)
-          connectionFactory.openConnection(new URL(url), isSpnego);
+        connectionFactory.openConnection(new URL(url), isSpnego);
     urlConnection.connect();
     return urlConnection;
   }
 
   /**
    * Load last known DB in Recon.
+   *
    * @param reconDbDir
    * @param fileNamePrefix
    * @return