Add co_applyToVirtualInode to VirtualInodeLoader

Summary:
Add a coroutine-native co_applyToVirtualInode that wraps the existing VirtualInodeLoader to resolve inodes, then applies the user-provided func via co_await instead of deferValue/collectAll. This is an intermediate step toward fully eliminating futures from the getBlake3 coroutine path — the loader itself still uses promises internally, but callers no longer need .semi() bridges on the outer ImmediateFuture.

Also adds CO_TEST(CoInodeLoader, load) which mirrors the existing InodeLoader.load test, covering happy path, non-existent paths, duplicate paths, and invalid paths through the coroutine interface.

Reviewed By: SBones

Differential Revision: D101696722

fbshipit-source-id: a4455f880f17edaf36947d83e45d8e14d8fdda51

Author: janezhang10

eden/fs/inodes/BUCK

@@ -184,7 +184,6 @@ cpp_library(
         "//folly:string",
         "//folly:unit",
         "//folly/chrono:conv",
-        "//folly/coro:collect",
         "//folly/coro:invoke",
         "//folly/io:iobuf",
         "//folly/io/async:async_base",
@@ -263,6 +262,7 @@ cpp_library(
         "//folly/concurrency/memory:atomic_read_mostly_main_ptr",
         "//folly/concurrency/memory:read_mostly_shared_ptr",
         "//folly/container:evicting_cache_map",
+        "//folly/coro:collect",
         "//folly/coro/safe:now_task",
         "//folly/functional:invoke",
         "//folly/futures:core",

eden/fs/inodes/VirtualInodeLoader.h

@@ -9,6 +9,8 @@
 #include <folly/ExceptionWrapper.h>
 #include <folly/FBVector.h>
 #include <folly/MapUtil.h>
+#include <folly/coro/Collect.h>
+#include <folly/coro/safe/NowTask.h>
 #include <folly/functional/Invoke.h>
 #include <folly/futures/Future.h>
 
@@ -190,4 +192,82 @@ auto applyToVirtualInode(
       });
 }
 
+/**
+ * Coroutine-native version of applyToVirtualInode. Uses the same
+ * VirtualInodeLoader for efficient tree-shaped path resolution, but applies
+ * func via co_await instead of deferValue/collectAll. func may return a
+ * SemiFuture<T> or now_task<T> — anything co_awaitable.
+ *
+ * Both inode resolution and func application are parallelized: resolution
+ * via the loader's tree-shaped plan, func via collectAllRange.
+ */
+template <typename Func>
+folly::coro::now_task<
+    std::vector<folly::Try<typename folly::isFutureOrSemiFuture<
+        folly::invoke_result_t<Func&, VirtualInode, RelativePath>>::Inner>>>
+co_applyToVirtualInode(
+    InodePtr rootInode,
+    const std::vector<std::string>& paths,
+    Func func,
+    const std::shared_ptr<ObjectStore>& store,
+    const ObjectFetchContextPtr& fetchContext) {
+  using FuncRet = folly::invoke_result_t<Func&, VirtualInode, RelativePath>;
+  using Result = typename folly::isFutureOrSemiFuture<FuncRet>::Inner;
+
+  detail::VirtualInodeLoader loader;
+
+  // Func may not be copyable, so wrap it in a shared_ptr.
+  auto cb = std::make_shared<Func>(std::move(func));
+
+  // Set up load futures for each path. If path parsing fails, store a failed
+  // SemiFuture so the error appears in the corresponding result entry.
+  std::vector<folly::SemiFuture<VirtualInode>> loadFutures;
+  std::vector<RelativePath> relPaths;
+  loadFutures.reserve(paths.size());
+  relPaths.reserve(paths.size());
+  for (const auto& path : paths) {
+    try {
+      auto relPath = RelativePathPiece{path};
+      loadFutures.push_back(loader.load(relPath));
+      relPaths.push_back(relPath.copy());
+    } catch (const std::exception&) {
+      loadFutures.push_back(
+          folly::makeSemiFuture<VirtualInode>(
+              folly::exception_wrapper(std::current_exception())));
+      relPaths.emplace_back();
+    }
+  }
+
+  // Resolve all inodes via the loader's tree-shaped plan.
+  co_await loader
+      .loaded(
+          folly::Try<VirtualInode>(VirtualInode{std::move(rootInode)}),
+          RelativePath(),
+          store,
+          fetchContext)
+      .semi();
+
+  // Apply func to each resolved inode in parallel.
+  std::vector<folly::coro::Task<folly::Try<Result>>> tasks;
+  tasks.reserve(loadFutures.size());
+  for (size_t i = 0; i < loadFutures.size(); ++i) {
+    tasks.push_back(
+        folly::coro::co_invoke(
+            [cb,
+             loadFuture = std::move(loadFutures[i]),
+             path = std::move(relPaths[i])]() mutable
+                -> folly::coro::Task<folly::Try<Result>> {
+              auto inodeTry =
+                  co_await folly::coro::co_awaitTry(std::move(loadFuture));
+              if (inodeTry.hasException()) {
+                co_return folly::Try<Result>(inodeTry.exception());
+              }
+              co_return co_await folly::coro::co_awaitTry(
+                  (*cb)(std::move(inodeTry.value()), std::move(path)));
+            }));
+  }
+
+  co_return co_await folly::coro::collectAllRange(std::move(tasks));
+}
+
 } // namespace facebook::eden

eden/fs/inodes/test/BUCK

@@ -234,6 +234,7 @@ cpp_unittest(
         "//eden/fs/testharness:fake_backing_store_and_tree_builder",
         "//eden/fs/testharness:test_checks",
         "//eden/fs/testharness:test_mount",
+        "//folly/coro:gtest_helpers",
         "//folly/test:test_utils",
         "//folly/testing:test_util",
     ],

eden/fs/inodes/test/VirtualInodeLoaderTest.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "eden/fs/inodes/VirtualInodeLoader.h"
+#include <folly/coro/GtestHelpers.h>
 #include <folly/test/TestUtils.h>
 #include <folly/testing/TestUtil.h>
 #include <gtest/gtest.h>
@@ -132,3 +133,78 @@ TEST(InodeLoader, notReady) {
     EXPECT_EQ(Hash20::sha1("dir/sub/b.txt"), results[3].value());
   }
 }
+
+CO_TEST(CoInodeLoader, load) {
+  FakeTreeBuilder builder;
+  builder.setFiles(FILES);
+  TestMount mount(builder);
+
+  auto rootInode = mount.getTreeInode(RelativePathPiece());
+  auto objectStore = mount.getEdenMount()->getObjectStore();
+  auto fetchContext = ObjectFetchContext::getNullContext();
+
+  {
+    auto results = co_await co_applyToVirtualInode(
+        rootInode,
+        std::vector<std::string>{
+            "dir/a.txt", "not/exist/a", "not/exist/b", "dir/sub/b.txt"},
+        [&](const VirtualInode& inode,
+            const RelativePath& path) -> folly::SemiFuture<Hash32> {
+          return inode.getBlake3(path, objectStore, fetchContext).semi();
+        },
+        objectStore,
+        fetchContext);
+
+    EXPECT_EQ(
+        Hash32::blake3(folly::ByteRange{folly::StringPiece{"dir/a.txt"}}),
+        results[0].value());
+    EXPECT_THROW_ERRNO(results[1].value(), ENOENT);
+    EXPECT_THROW_ERRNO(results[2].value(), ENOENT);
+    EXPECT_EQ(
+        Hash32::blake3(folly::ByteRange{folly::StringPiece{"dir/sub/b.txt"}}),
+        results[3].value());
+  }
+
+  {
+    auto results = co_await co_applyToVirtualInode(
+        rootInode,
+        std::vector<std::string>{
+            "dir/sub/b.txt",
+            "dir/a.txt",
+            "not/exist/a",
+            "not/exist/b",
+            "dir/sub/b.txt"},
+        [&](const VirtualInode& inode, const RelativePath& path) {
+          return inode.getBlake3(path, objectStore, fetchContext).semi();
+        },
+        objectStore,
+        fetchContext);
+
+    EXPECT_EQ(
+        Hash32::blake3(folly::ByteRange{folly::StringPiece{"dir/sub/b.txt"}}),
+        results[0].value());
+    EXPECT_EQ(
+        Hash32::blake3(folly::ByteRange{folly::StringPiece{"dir/a.txt"}}),
+        results[1].value());
+    EXPECT_THROW_ERRNO(results[2].value(), ENOENT);
+    EXPECT_THROW_ERRNO(results[3].value(), ENOENT);
+    EXPECT_EQ(results[0].value(), results[4].value())
+        << "dir/sub/b.txt was requested twice and both entries are the same";
+  }
+
+  {
+    auto results = co_await co_applyToVirtualInode(
+        rootInode,
+        std::vector<std::string>{"dir/a.txt", "/invalid///exist/a"},
+        [&](const VirtualInode& inode, const RelativePath& path) {
+          return inode.getBlake3(path, objectStore, fetchContext).semi();
+        },
+        objectStore,
+        fetchContext);
+
+    EXPECT_EQ(
+        Hash32::blake3(folly::ByteRange{folly::StringPiece{"dir/a.txt"}}),
+        results[0].value());
+    EXPECT_THROW_RE(results[1].value(), std::domain_error, "absolute path");
+  }
+}