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".

Author: Ericson2314

src/libstore/daemon.cc

@@ -423,7 +423,7 @@ static void performOp(TunnelLogger * logger, ref<Store> store,
             }();
             logger->stopWork();
 
-            pathInfo->write(to, *store, GET_PROTOCOL_MINOR(clientVersion));
+            worker_proto::write(*store, wconn, *pathInfo);
         } else {
             HashType hashAlgo;
             std::string baseName;
@@ -817,7 +817,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);
+            worker_proto::write(*store, wconn, *info, false);
         } else {
             assert(GET_PROTOCOL_MINOR(clientVersion) >= 17);
             to << 0;

src/libstore/path-info.cc

@@ -105,11 +105,6 @@ struct ValidPathInfo
     ValidPathInfo(const StorePath & path, Hash narHash) : path(path), narHash(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/path-info.hh

@@ -331,7 +331,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}));
+                worker_proto::readValidPathInfo(*this, *conn, StorePath{path}));
         }
         callback(std::move(info));
     } catch (...) { callback.rethrow(); }
@@ -434,7 +434,7 @@ ref<const ValidPathInfo> RemoteStore::addCAToStore(
         }
 
         return make_ref<ValidPathInfo>(
-            ValidPathInfo::read(conn->from, *this, GET_PROTOCOL_MINOR(conn->daemonVersion)));
+            worker_proto::readValidPathInfo(*this, *conn));
     }
     else {
         if (repair) throw Error("repairing is not supported when building through the Nix daemon protocol < 1.25");

src/libstore/remote-store.cc

@@ -11,6 +11,8 @@
 #include "archive.hh"
 #include "callback.hh"
 #include "remote-store.hh"
+// FIXME this should not be here
+#include "worker-protocol.hh"
 
 #include <regex>
 
@@ -266,7 +268,11 @@ void Store::addMultipleToStore(
 {
     auto expected = readNum<uint64_t>(source);
     for (uint64_t i = 0; i < expected; ++i) {
-        auto info = ValidPathInfo::read(source, *this, 16);
+        auto info = worker_proto::readValidPathInfo(*this,
+            worker_proto::ReadConn {
+                { .from = source },
+                .version = 16,
+            });
         info.ultimate = false;
         addToStore(info, source, repair, checkSigs);
     }
@@ -978,6 +984,7 @@ std::map<StorePath, StorePath> copyPaths(
     return pathsMap;
 }
 
+
 std::map<StorePath, StorePath> copyPaths(
     Store & srcStore,
     Store & dstStore,
@@ -1013,7 +1020,12 @@ std::map<StorePath, StorePath> copyPaths(
             PushActivity pact(act.id);
 
             auto info = srcStore.queryPathInfo(storePath);
-            info->write(sink, srcStore, 16);
+            worker_proto::write(srcStore,
+                worker_proto::WriteConn {
+                    { .to = sink },
+                    .version = 16,
+                },
+                *info);
             srcStore.narFromPath(storePath, sink);
         }
     });

src/libstore/store-api.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>
 
@@ -44,5 +44,48 @@ void write(const Store & store, WriteConn conn, const BuildResult & res)
 }
 
 
+ValidPathInfo readValidPathInfo(const Store & store, ReadConn conn)
+{
+    auto path = read(store, conn, Phantom<StorePath>{});
+    return readValidPathInfo(store, conn, std::move(path));
+}
+
+ValidPathInfo readValidPathInfo(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 = read(store, conn, Phantom<StorePathSet> {});
+    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 = parseContentAddressOpt(readString(conn.from));
+    }
+    return info;
+}
+
+void 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(Base16, false);
+    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.cc

@@ -75,6 +75,7 @@ struct Source;
 
 // items being serialized
 struct BuildResult;
+struct PathInfo;
 
 
 namespace worker_proto {
@@ -103,6 +104,13 @@ MAKE_PROTO(X_, Y_);
 #undef X_
 #undef Y_
 
+/* These are a non-standard form for historical reasons. */
+
+ValidPathInfo readValidPathInfo(const Store & store, ReadConn conn);
+ValidPathInfo readValidPathInfo(const Store & store, ReadConn conn, StorePath && path);
+
+void write(const Store & store, WriteConn conn, const ValidPathInfo & pathInfo, bool includePath = true);
+
 }
 
 }