Create header for LegacySSHStore

In https://github.com/NixOS/nix/pull/6134#issuecomment-1079199888,
@thuffschmitt proposed exposing `LegacySSHStore` in Nix for
deduplication with Hydra, at least temporarily. I think that is a good
idea.

Note that the diff will look bad unless one ignores whitespace! Also try
this locally:

```shell-session
git diff --ignore-all-space HEAD^:src/libstore/legacy-ssh-store.cc HEAD:src/libstore/legacy-ssh-store.cc
git diff --ignore-all-space HEAD^:src/libstore/legacy-ssh-store.cc HEAD:src/libstore/legacy-ssh-store.hh
```

src/libstore/legacy-ssh-store.cc

@@ -1,3 +1,4 @@
+#include "legacy-ssh-store.hh"
 #include "ssh-store-config.hh"
 #include "archive.hh"
 #include "pool.hh"
@@ -13,34 +14,15 @@
 
 namespace nix {
 
-struct LegacySSHStoreConfig : virtual CommonSSHStoreConfig
+std::string LegacySSHStoreConfig::doc()
-{
-    using CommonSSHStoreConfig::CommonSSHStoreConfig;
-
-    const Setting<Path> remoteProgram{this, "nix-store", "remote-program",
-        "Path to the `nix-store` executable on the remote machine."};
-
-    const Setting<int> maxConnections{this, 1, "max-connections",
-        "Maximum number of concurrent SSH connections."};
-
-    const std::string name() override { return "SSH Store"; }
-
-    std::string doc() override
 {
     return
       #include "legacy-ssh-store.md"
       ;
 }
-};
 
-struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Store
-{
-    // Hack for getting remote build log output.
-    // Intentionally not in `LegacySSHStoreConfig` so that it doesn't appear in
-    // the documentation
-    const Setting<int> logFD{this, -1, "log-fd", "file descriptor to which SSH's stderr is connected"};
 
-    struct Connection
+struct LegacySSHStore::Connection
 {
     std::unique_ptr<SSHMaster::Connection> sshConn;
     FdSink to;
@@ -81,15 +63,8 @@ struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Stor
     }
 };
 
-    std::string host;
 
-    ref<Pool<Connection>> connections;
+LegacySSHStore::LegacySSHStore(const std::string & scheme, const std::string & host, const Params & params)
-
-    SSHMaster master;
-
-    static std::set<std::string> uriSchemes() { return {"ssh"}; }
-
-    LegacySSHStore(const std::string & scheme, const std::string & host, const Params & params)
     : StoreConfig(params)
     , CommonSSHStoreConfig(params)
     , LegacySSHStoreConfig(params)
@@ -111,7 +86,8 @@ struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Stor
 {
 }
 
-    ref<Connection> openConnection()
+
+ref<LegacySSHStore::Connection> LegacySSHStore::openConnection()
 {
     auto conn = make_ref<Connection>();
     conn->sshConn = master.startCommand(
@@ -149,13 +125,15 @@ struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Stor
     return conn;
 };
 
-    std::string getUri() override
+
+std::string LegacySSHStore::getUri()
 {
     return *uriSchemes().begin() + "://" + host;
 }
 
-    void queryPathInfoUncached(const StorePath & path,
+
-        Callback<std::shared_ptr<const ValidPathInfo>> callback) noexcept override
+void LegacySSHStore::queryPathInfoUncached(const StorePath & path,
+    Callback<std::shared_ptr<const ValidPathInfo>> callback) noexcept
 {
     try {
         auto conn(connections->get());
@@ -186,8 +164,9 @@ struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Stor
     } catch (...) { callback.rethrow(); }
 }
 
-    void addToStore(const ValidPathInfo & info, Source & source,
+
-        RepairFlag repair, CheckSigsFlag checkSigs) override
+void LegacySSHStore::addToStore(const ValidPathInfo & info, Source & source,
+    RepairFlag repair, CheckSigsFlag checkSigs)
 {
     debug("adding path '%s' to remote host '%s'", printStorePath(info.path), host);
 
@@ -242,7 +221,8 @@ struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Stor
         throw Error("failed to add path '%s' to remote host '%s'", printStorePath(info.path), host);
 }
 
-    void narFromPath(const StorePath & path, Sink & sink) override
+
+void LegacySSHStore::narFromPath(const StorePath & path, Sink & sink)
 {
     auto conn(connections->get());
 
@@ -251,29 +231,8 @@ struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Stor
     copyNAR(conn->from, sink);
 }
 
-    std::optional<StorePath> queryPathFromHashPart(const std::string & hashPart) override
-    { unsupported("queryPathFromHashPart"); }
 
-    StorePath addToStore(
+void LegacySSHStore::putBuildSettings(Connection & conn)
-            std::string_view name,
-            const Path & srcPath,
-            FileIngestionMethod method,
-            HashAlgorithm hashAlgo,
-            PathFilter & filter,
-            RepairFlag repair,
-            const StorePathSet & references) override
-    { unsupported("addToStore"); }
-
-    StorePath addTextToStore(
-        std::string_view name,
-        std::string_view s,
-        const StorePathSet & references,
-        RepairFlag repair) override
-    { unsupported("addTextToStore"); }
-
-private:
-
-    void putBuildSettings(Connection & conn)
 {
     ServeProto::write(*this, conn, ServeProto::BuildOptions {
         .maxSilentTime = settings.maxSilentTime,
@@ -285,10 +244,9 @@ private:
     });
 }
 
-public:
 
-    BuildResult buildDerivation(const StorePath & drvPath, const BasicDerivation & drv,
+BuildResult LegacySSHStore::buildDerivation(const StorePath & drvPath, const BasicDerivation & drv,
-        BuildMode buildMode) override
+    BuildMode buildMode)
 {
     auto conn(connections->get());
 
@@ -304,7 +262,8 @@ public:
     return ServeProto::Serialise<BuildResult>::read(*this, *conn);
 }
 
-    void buildPaths(const std::vector<DerivedPath> & drvPaths, BuildMode buildMode, std::shared_ptr<Store> evalStore) override
+
+void LegacySSHStore::buildPaths(const std::vector<DerivedPath> & drvPaths, BuildMode buildMode, std::shared_ptr<Store> evalStore)
 {
     if (evalStore && evalStore.get() != this)
         throw Error("building on an SSH store is incompatible with '--eval-store'");
@@ -342,26 +301,10 @@ public:
     }
 }
 
-    void ensurePath(const StorePath & path) override
-    { unsupported("ensurePath"); }
 
-    virtual ref<SourceAccessor> getFSAccessor(bool requireValidPath) override
+void LegacySSHStore::computeFSClosure(const StorePathSet & paths,
-    { unsupported("getFSAccessor"); }
+    StorePathSet & out, bool flipDirection,
-
+    bool includeOutputs, bool includeDerivers)
-    /**
-     * The default instance would schedule the work on the client side, but
-     * for consistency with `buildPaths` and `buildDerivation` it should happen
-     * on the remote side.
-     *
-     * We make this fail for now so we can add implement this properly later
-     * without it being a breaking change.
-     */
-    void repairPath(const StorePath & path) override
-    { unsupported("repairPath"); }
-
-    void computeFSClosure(const StorePathSet & paths,
-        StorePathSet & out, bool flipDirection = false,
-        bool includeOutputs = false, bool includeDerivers = false) override
 {
     if (flipDirection || includeDerivers) {
         Store::computeFSClosure(paths, out, flipDirection, includeOutputs, includeDerivers);
@@ -380,8 +323,9 @@ public:
         out.insert(i);
 }
 
-    StorePathSet queryValidPaths(const StorePathSet & paths,
+
-        SubstituteFlag maybeSubstitute = NoSubstitute) override
+StorePathSet LegacySSHStore::queryValidPaths(const StorePathSet & paths,
+    SubstituteFlag maybeSubstitute)
 {
     auto conn(connections->get());
 
@@ -395,31 +339,29 @@ public:
     return ServeProto::Serialise<StorePathSet>::read(*this, *conn);
 }
 
-    void connect() override
+
+void LegacySSHStore::connect()
 {
     auto conn(connections->get());
 }
 
-    unsigned int getProtocol() override
+
+unsigned int LegacySSHStore::getProtocol()
 {
     auto conn(connections->get());
     return conn->remoteVersion;
 }
 
+
 /**
  * The legacy ssh protocol doesn't support checking for trusted-user.
  * Try using ssh-ng:// instead if you want to know.
  */
-    std::optional<TrustedFlag> isTrustedClient() override
+std::optional<TrustedFlag> isTrustedClient()
 {
     return std::nullopt;
 }
 
-    void queryRealisationUncached(const DrvOutput &,
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override
-    // TODO: Implement
-    { unsupported("queryRealisation"); }
-};
 
 static RegisterStoreImplementation<LegacySSHStore, LegacySSHStoreConfig> regLegacySSHStore;
 

src/libstore/legacy-ssh-store.hh

@@ -0,0 +1,132 @@
+#pragma once
+///@file
+
+#include "ssh-store-config.hh"
+#include "store-api.hh"
+#include "ssh.hh"
+#include "callback.hh"
+#include "pool.hh"
+
+namespace nix {
+
+struct LegacySSHStoreConfig : virtual CommonSSHStoreConfig
+{
+    using CommonSSHStoreConfig::CommonSSHStoreConfig;
+
+    const Setting<Path> remoteProgram{this, "nix-store", "remote-program",
+        "Path to the `nix-store` executable on the remote machine."};
+
+    const Setting<int> maxConnections{this, 1, "max-connections",
+        "Maximum number of concurrent SSH connections."};
+
+    const std::string name() override { return "SSH Store"; }
+
+    std::string doc() override;
+};
+
+struct LegacySSHStore : public virtual LegacySSHStoreConfig, public virtual Store
+{
+    // Hack for getting remote build log output.
+    // Intentionally not in `LegacySSHStoreConfig` so that it doesn't appear in
+    // the documentation
+    const Setting<int> logFD{this, -1, "log-fd", "file descriptor to which SSH's stderr is connected"};
+
+    struct Connection;
+
+    std::string host;
+
+    ref<Pool<Connection>> connections;
+
+    SSHMaster master;
+
+    static std::set<std::string> uriSchemes() { return {"ssh"}; }
+
+    LegacySSHStore(const std::string & scheme, const std::string & host, const Params & params);
+
+    ref<Connection> openConnection();
+
+    std::string getUri() override;
+
+    void queryPathInfoUncached(const StorePath & path,
+        Callback<std::shared_ptr<const ValidPathInfo>> callback) noexcept override;
+
+    void addToStore(const ValidPathInfo & info, Source & source,
+        RepairFlag repair, CheckSigsFlag checkSigs) override;
+
+    void narFromPath(const StorePath & path, Sink & sink) override;
+
+    std::optional<StorePath> queryPathFromHashPart(const std::string & hashPart) override
+    { unsupported("queryPathFromHashPart"); }
+
+    StorePath addToStore(
+            std::string_view name,
+            const Path & srcPath,
+            FileIngestionMethod method,
+            HashAlgorithm hashAlgo,
+            PathFilter & filter,
+            RepairFlag repair,
+            const StorePathSet & references) override
+    { unsupported("addToStore"); }
+
+    StorePath addTextToStore(
+        std::string_view name,
+        std::string_view s,
+        const StorePathSet & references,
+        RepairFlag repair) override
+    { unsupported("addTextToStore"); }
+
+private:
+
+    void putBuildSettings(Connection & conn);
+
+public:
+
+    BuildResult buildDerivation(const StorePath & drvPath, const BasicDerivation & drv,
+        BuildMode buildMode) override;
+
+    void buildPaths(const std::vector<DerivedPath> & drvPaths, BuildMode buildMode, std::shared_ptr<Store> evalStore) override;
+
+    void ensurePath(const StorePath & path) override
+    { unsupported("ensurePath"); }
+
+    virtual ref<SourceAccessor> getFSAccessor(bool requireValidPath) override
+    { unsupported("getFSAccessor"); }
+
+    /**
+     * The default instance would schedule the work on the client side, but
+     * for consistency with `buildPaths` and `buildDerivation` it should happen
+     * on the remote side.
+     *
+     * We make this fail for now so we can add implement this properly later
+     * without it being a breaking change.
+     */
+    void repairPath(const StorePath & path) override
+    { unsupported("repairPath"); }
+
+    void computeFSClosure(const StorePathSet & paths,
+        StorePathSet & out, bool flipDirection = false,
+        bool includeOutputs = false, bool includeDerivers = false) override;
+
+    StorePathSet queryValidPaths(const StorePathSet & paths,
+        SubstituteFlag maybeSubstitute = NoSubstitute) override;
+
+    void connect() override;
+
+    unsigned int getProtocol() override;
+
+    /**
+     * The legacy ssh protocol doesn't support checking for trusted-user.
+     * Try using ssh-ng:// instead if you want to know.
+     */
+    std::optional<TrustedFlag> isTrustedClient() override
+    {
+        return std::nullopt;
+    }
+
+    void queryRealisationUncached(const DrvOutput &,
+        Callback<std::shared_ptr<const Realisation>> callback) noexcept override
+    // TODO: Implement
+    { unsupported("queryRealisation"); }
+};
+
+}