RemoteFSAccessor: Make the local NAR cache content-addressed

Author: edolstra

src/libstore/include/nix/store/remote-fs-accessor.hh

@@ -21,9 +21,13 @@ class RemoteFSAccessor : public SourceAccessor
 
     friend struct BinaryCacheStore;
 
-    std::filesystem::path makeCacheFile(std::string_view hashPart, const std::string & ext);
+    std::filesystem::path makeCacheFile(const Hash & narHash, const std::string & ext);
 
-    ref<SourceAccessor> addToCache(std::string_view hashPart, std::string && nar);
+    ref<SourceAccessor> addToCache(
+        std::string_view hashPart,
+        const std::filesystem::path & cacheFile,
+        const std::filesystem::path & listingFile,
+        std::string && nar);
 
 public:
 

src/libstore/remote-fs-accessor.cc

@@ -17,18 +17,22 @@ RemoteFSAccessor::RemoteFSAccessor(ref<Store> store, bool requireValidPath, std:
         createDirs(cacheDir);
 }
 
-std::filesystem::path RemoteFSAccessor::makeCacheFile(std::string_view hashPart, const std::string & ext)
+std::filesystem::path RemoteFSAccessor::makeCacheFile(const Hash & narHash, const std::string & ext)
 {
     assert(!cacheDir.empty());
-    return (cacheDir / hashPart) + "." + ext;
+    return (cacheDir / narHash.to_string(HashFormat::Nix32, false)) + "." + ext;
 }
 
-ref<SourceAccessor> RemoteFSAccessor::addToCache(std::string_view hashPart, std::string && nar)
+ref<SourceAccessor> RemoteFSAccessor::addToCache(
+    std::string_view hashPart,
+    const std::filesystem::path & cacheFile,
+    const std::filesystem::path & listingFile,
+    std::string && nar)
 {
-    if (!cacheDir.empty()) {
+    if (!cacheFile.empty()) {
         try {
             /* FIXME: do this asynchronously. */
-            writeFile(makeCacheFile(hashPart, "nar"), nar);
+            writeFile(cacheFile, nar);
         } catch (...) {
             ignoreExceptionExceptInterrupt();
         }
@@ -37,10 +41,10 @@ ref<SourceAccessor> RemoteFSAccessor::addToCache(std::string_view hashPart, std:
     auto narAccessor = makeNarAccessor(std::move(nar));
     nars.emplace(hashPart, narAccessor);
 
-    if (!cacheDir.empty()) {
+    if (!listingFile.empty()) {
         try {
             nlohmann::json j = listNar(narAccessor, CanonPath::root, true);
-            writeFile(makeCacheFile(hashPart, "ls"), j.dump());
+            writeFile(listingFile, j.dump());
         } catch (...) {
             ignoreExceptionExceptInterrupt();
         }
@@ -63,51 +67,55 @@ std::shared_ptr<SourceAccessor> RemoteFSAccessor::accessObject(const StorePath &
     if (i != nars.end())
         return i->second;
 
-    std::string listing;
-    std::filesystem::path cacheFile;
-
-    if (!cacheDir.empty() && nix::pathExists(cacheFile = makeCacheFile(storePath.hashPart(), "nar"))) {
-
-        try {
-            listing = nix::readFile(makeCacheFile(storePath.hashPart(), "ls"));
+    std::filesystem::path cacheFile, listingFile;
 
-            auto narAccessor = makeLazyNarAccessor(listing, [cacheFile](uint64_t offset, uint64_t length) {
-                AutoCloseFD fd = toDescriptor(open(
-                    cacheFile.c_str(),
-                    O_RDONLY
+    if (!cacheDir.empty()) {
+        auto info = store->queryPathInfo(storePath);
+
+        cacheFile = makeCacheFile(info->narHash, "nar");
+        listingFile = makeCacheFile(info->narHash, "ls");
+
+        if (nix::pathExists(cacheFile)) {
+            try {
+                auto listing = nix::readFile(listingFile);
+                auto narAccessor = makeLazyNarAccessor(listing, [cacheFile](uint64_t offset, uint64_t length) {
+                    AutoCloseFD fd = toDescriptor(open(
+                        cacheFile.c_str(),
+                        O_RDONLY
 #ifndef _WIN32
-                        | O_CLOEXEC
+                            | O_CLOEXEC
 #endif
-                    ));
-                if (!fd)
-                    throw SysError("opening NAR cache file '%s'", cacheFile);
+                        ));
+                    if (!fd)
+                        throw SysError("opening NAR cache file '%s'", cacheFile);
 
-                if (lseek(fromDescriptorReadOnly(fd.get()), offset, SEEK_SET) != (off_t) offset)
-                    throw SysError("seeking in '%s'", cacheFile);
+                    if (lseek(fromDescriptorReadOnly(fd.get()), offset, SEEK_SET) != (off_t) offset)
+                        throw SysError("seeking in '%s'", cacheFile);
 
-                std::string buf(length, 0);
-                readFull(fd.get(), buf.data(), length);
+                    std::string buf(length, 0);
+                    readFull(fd.get(), buf.data(), length);
 
-                return buf;
-            });
+                    return buf;
+                });
 
-            nars.emplace(storePath.hashPart(), narAccessor);
-            return narAccessor;
+                nars.emplace(storePath.hashPart(), narAccessor);
+                return narAccessor;
 
-        } catch (SystemError &) {
-        }
+            } catch (SystemError &) {
+            }
 
-        try {
-            auto narAccessor = makeNarAccessor(nix::readFile(cacheFile));
-            nars.emplace(storePath.hashPart(), narAccessor);
-            return narAccessor;
-        } catch (SystemError &) {
+            try {
+                auto narAccessor = makeNarAccessor(nix::readFile(cacheFile));
+                nars.emplace(storePath.hashPart(), narAccessor);
+                return narAccessor;
+            } catch (SystemError &) {
+            }
         }
     }
 
     StringSink sink;
     store->narFromPath(storePath, sink);
-    return addToCache(storePath.hashPart(), std::move(sink.s));
+    return addToCache(storePath.hashPart(), cacheFile, listingFile, std::move(sink.s));
 }
 
 std::optional<SourceAccessor::Stat> RemoteFSAccessor::maybeLstat(const CanonPath & path)