Move ValidPathInfo serialization code to worker-protocol.{cc.hh}

It does not belong with the data type itself.

This also materializes the fact that `copyPath` does not do any version
negotiation just just hard-codes "16".

The non-standard interface of these serializers makes it harder to test,
but this is fixed in the next commit which then adds those tests.

src/libstore/daemon.cc

@@ -422,7 +422,7 @@ static void performOp(TunnelLogger * logger, ref<Store> store,
             }();
             logger->stopWork();
 
-            pathInfo->write(to, *store, GET_PROTOCOL_MINOR(clientVersion));
+            WorkerProto::Serialise<ValidPathInfo>::write(*store, wconn, *pathInfo);
         } else {
             HashType hashAlgo;
             std::string baseName;
@@ -819,7 +819,7 @@ static void performOp(TunnelLogger * logger, ref<Store> store,
         if (info) {
             if (GET_PROTOCOL_MINOR(clientVersion) >= 17)
                 to << 1;
-            info->write(to, *store, GET_PROTOCOL_MINOR(clientVersion), false);
+            WorkerProto::Serialise<ValidPathInfo>::write(*store, wconn, *info, false);
         } else {
             assert(GET_PROTOCOL_MINOR(clientVersion) >= 17);
             to << 0;

src/libstore/path-info.cc

@@ -1,6 +1,4 @@
 #include "path-info.hh"
-#include "worker-protocol.hh"
-#include "worker-protocol-impl.hh"
 #include "store-api.hh"
 
 namespace nix {
@@ -99,7 +97,6 @@ Strings ValidPathInfo::shortRefs() const
     return refs;
 }
 
-
 ValidPathInfo::ValidPathInfo(
     const Store & store,
     std::string_view name,
@@ -128,55 +125,4 @@ ValidPathInfo::ValidPathInfo(
     }, std::move(ca).raw);
 }
 
-
-ValidPathInfo ValidPathInfo::read(Source & source, const Store & store, unsigned int format)
-{
-    return read(source, store, format, store.parseStorePath(readString(source)));
-}
-
-ValidPathInfo ValidPathInfo::read(Source & source, const Store & store, unsigned int format, StorePath && path)
-{
-    auto deriver = readString(source);
-    auto narHash = Hash::parseAny(readString(source), htSHA256);
-    ValidPathInfo info(path, narHash);
-    if (deriver != "") info.deriver = store.parseStorePath(deriver);
-    info.references = WorkerProto::Serialise<StorePathSet>::read(store,
-        WorkerProto::ReadConn {
-            .from = source,
-            .version = format,
-        });
-    source >> info.registrationTime >> info.narSize;
-    if (format >= 16) {
-        source >> info.ultimate;
-        info.sigs = readStrings<StringSet>(source);
-        info.ca = ContentAddress::parseOpt(readString(source));
-    }
-    return info;
-}
-
-
-void ValidPathInfo::write(
-    Sink & sink,
-    const Store & store,
-    unsigned int format,
-    bool includePath) const
-{
-    if (includePath)
-        sink << store.printStorePath(path);
-    sink << (deriver ? store.printStorePath(*deriver) : "")
-         << narHash.to_string(HashFormat::Base16, false);
-    WorkerProto::write(store,
-        WorkerProto::WriteConn {
-            .to = sink,
-            .version = format,
-        },
-        references);
-    sink << registrationTime << narSize;
-    if (format >= 16) {
-        sink << ultimate
-             << sigs
-             << renderContentAddress(ca);
-    }
-}
-
 }

src/libstore/path-info.hh

@@ -121,11 +121,6 @@ struct ValidPathInfo
         std::string_view name, ContentAddressWithReferences && ca, Hash narHash);
 
     virtual ~ValidPathInfo() { }
-
-    static ValidPathInfo read(Source & source, const Store & store, unsigned int format);
-    static ValidPathInfo read(Source & source, const Store & store, unsigned int format, StorePath && path);
-
-    void write(Sink & sink, const Store & store, unsigned int format, bool includePath = true) const;
 };
 
 typedef std::map<StorePath, ValidPathInfo> ValidPathInfos;

src/libstore/remote-store.cc

@@ -332,7 +332,7 @@ void RemoteStore::queryPathInfoUncached(const StorePath & path,
                 if (!valid) throw InvalidPath("path '%s' is not valid", printStorePath(path));
             }
             info = std::make_shared<ValidPathInfo>(
-                ValidPathInfo::read(conn->from, *this, GET_PROTOCOL_MINOR(conn->daemonVersion), StorePath{path}));
+                WorkerProto::Serialise<ValidPathInfo>::read(*this, *conn, StorePath{path}));
         }
         callback(std::move(info));
     } catch (...) { callback.rethrow(); }
@@ -445,7 +445,7 @@ ref<const ValidPathInfo> RemoteStore::addCAToStore(
         }
 
         return make_ref<ValidPathInfo>(
-            ValidPathInfo::read(conn->from, *this, GET_PROTOCOL_MINOR(conn->daemonVersion)));
+            WorkerProto::Serialise<ValidPathInfo>::read(*this, *conn));
     }
     else {
         if (repair) throw Error("repairing is not supported when building through the Nix daemon protocol < 1.25");
@@ -570,7 +570,12 @@ void RemoteStore::addMultipleToStore(
     auto source = sinkToSource([&](Sink & sink) {
         sink << pathsToCopy.size();
         for (auto & [pathInfo, pathSource] : pathsToCopy) {
-            pathInfo.write(sink, *this, 16);
+            WorkerProto::Serialise<ValidPathInfo>::write(*this,
+                 WorkerProto::WriteConn {
+                     .to = sink,
+                     .version = 16,
+                 },
+                 pathInfo);
             pathSource->drainInto(sink);
         }
     });

src/libstore/store-api.cc

@@ -11,6 +11,9 @@
 #include "archive.hh"
 #include "callback.hh"
 #include "remote-store.hh"
+// FIXME this should not be here, see TODO below on
+// `addMultipleToStore`.
+#include "worker-protocol.hh"
 
 #include <nlohmann/json.hpp>
 #include <regex>
@@ -357,7 +360,13 @@ void Store::addMultipleToStore(
 {
     auto expected = readNum<uint64_t>(source);
     for (uint64_t i = 0; i < expected; ++i) {
-        auto info = ValidPathInfo::read(source, *this, 16);
+        // FIXME we should not be using the worker protocol here, let
+        // alone the worker protocol with a hard-coded version!
+        auto info = WorkerProto::Serialise<ValidPathInfo>::read(*this,
+            WorkerProto::ReadConn {
+                .from = source,
+                .version = 16,
+            });
         info.ultimate = false;
         addToStore(info, source, repair, checkSigs);
     }

src/libstore/worker-protocol.cc

@@ -6,7 +6,7 @@
 #include "worker-protocol.hh"
 #include "worker-protocol-impl.hh"
 #include "archive.hh"
-#include "derivations.hh"
+#include "path-info.hh"
 
 #include <nlohmann/json.hpp>
 
@@ -142,4 +142,47 @@ void WorkerProto::Serialise<BuildResult>::write(const Store & store, WorkerProto
 }
 
 
+ValidPathInfo WorkerProto::Serialise<ValidPathInfo>::read(const Store & store, ReadConn conn)
+{
+    auto path = WorkerProto::Serialise<StorePath>::read(store, conn);
+    return WorkerProto::Serialise<ValidPathInfo>::read(store, conn, std::move(path));
+}
+
+ValidPathInfo WorkerProto::Serialise<ValidPathInfo>::read(const Store & store, ReadConn conn, StorePath && path)
+{
+    auto deriver = readString(conn.from);
+    auto narHash = Hash::parseAny(readString(conn.from), htSHA256);
+    ValidPathInfo info(path, narHash);
+    if (deriver != "") info.deriver = store.parseStorePath(deriver);
+    info.references = WorkerProto::Serialise<StorePathSet>::read(store, conn);
+    conn.from >> info.registrationTime >> info.narSize;
+    if (GET_PROTOCOL_MINOR(conn.version) >= 16) {
+        conn.from >> info.ultimate;
+        info.sigs = readStrings<StringSet>(conn.from);
+        info.ca = ContentAddress::parseOpt(readString(conn.from));
+    }
+    return info;
+}
+
+void WorkerProto::Serialise<ValidPathInfo>::write(
+    const Store & store,
+    WriteConn conn,
+    const ValidPathInfo & pathInfo,
+    bool includePath)
+{
+    if (includePath)
+        conn.to << store.printStorePath(pathInfo.path);
+    conn.to
+        << (pathInfo.deriver ? store.printStorePath(*pathInfo.deriver) : "")
+        << pathInfo.narHash.to_string(HashFormat::Base16, false);
+    WorkerProto::write(store, conn, pathInfo.references);
+    conn.to << pathInfo.registrationTime << pathInfo.narSize;
+    if (GET_PROTOCOL_MINOR(conn.version) >= 16) {
+        conn.to
+            << pathInfo.ultimate
+            << pathInfo.sigs
+            << renderContentAddress(pathInfo.ca);
+    }
+}
+
 }

src/libstore/worker-protocol.hh

@@ -31,6 +31,7 @@ struct Source;
 struct DerivedPath;
 struct BuildResult;
 struct KeyedBuildResult;
+struct ValidPathInfo;
 enum TrustedFlag : bool;
 
 
@@ -220,4 +221,15 @@ template<typename K, typename V>
 DECLARE_WORKER_SERIALISER(std::map<K COMMA_ V>);
 #undef COMMA_
 
+/* These are a non-standard form for historical reasons. */
+
+template<>
+struct WorkerProto::Serialise<ValidPathInfo>
+{
+    static ValidPathInfo read(const Store & store, WorkerProto::ReadConn conn);
+    static ValidPathInfo read(const Store & store, WorkerProto::ReadConn conn, StorePath && path);
+
+    static void write(const Store & store, WriteConn conn, const ValidPathInfo & pathInfo, bool includePath = true);
+};
+
 }