Refactor unix domain socket store config

src/libstore/store-api.cc

@@ -1289,7 +1289,12 @@ ref<Store> openStore(StoreReference && storeURI)
             if (access(stateDir.c_str(), R_OK | W_OK) == 0)
                 return std::make_shared<LocalStore>(params);
             else if (pathExists(settings.nixDaemonSocketFile))
-                return std::make_shared<UDSRemoteStore>(params);
+                // TODO(fzakaria): A bit gross that we now pass empty string
+                // but this is knowing that empty string will later default to the same
+                // nixDaemonSocketFile. Why don't we just wire it all through?
+                // I believe there are cases where it will live reload so we want to
+                // continue to account for that.
+                return std::make_shared<UDSRemoteStore>(UDSRemoteStoreConfig::scheme, "", params);
             #if __linux__
             else if (!pathExists(stateDir)
                 && params.empty()

src/libstore/uds-remote-store.cc

@@ -2,12 +2,11 @@
 #include "unix-domain-socket.hh"
 #include "worker-protocol.hh"
 
-#include <cstring>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <format>
 
 #ifdef _WIN32
 # include <winsock2.h>
@@ -27,37 +26,25 @@ std::string UDSRemoteStoreConfig::doc()
 }
 
 
-UDSRemoteStore::UDSRemoteStore(const Params & params)
+UDSRemoteStore::UDSRemoteStore(std::string_view scheme, std::string_view authority, const Params & params)
     : StoreConfig(params)
     , LocalFSStoreConfig(params)
     , RemoteStoreConfig(params)
-    , UDSRemoteStoreConfig(params)
+    , UDSRemoteStoreConfig(scheme, authority, params)
     , Store(params)
     , LocalFSStore(params)
     , RemoteStore(params)
 {
 }
 
-
-UDSRemoteStore::UDSRemoteStore(
-    std::string_view scheme,
-    PathView socket_path,
-    const Params & params)
-    : UDSRemoteStore(params)
+std::string UDSRemoteStore::getPathOrDefault() const
 {
-    if (!socket_path.empty())
-        path.emplace(socket_path);
+    return path.value_or(settings.nixDaemonSocketFile);
 }
 
-
 std::string UDSRemoteStore::getUri()
 {
-    if (path) {
-        return std::string("unix://") + *path;
-    } else {
-        // unix:// with no path also works. Change what we return?
-        return "daemon";
-    }
+    return std::format("{}://{}", scheme, getPathOrDefault());
 }
 
 
@@ -74,7 +61,7 @@ ref<RemoteStore::Connection> UDSRemoteStore::openConnection()
     /* Connect to a daemon that does the privileged work for us. */
     conn->fd = createUnixDomainSocket();
 
-    nix::connect(toSocket(conn->fd.get()), path ? *path : settings.nixDaemonSocketFile);
+    nix::connect(toSocket(conn->fd.get()), getPathOrDefault());
 
     conn->from.fd = conn->fd.get();
     conn->to.fd = conn->fd.get();

src/libstore/uds-remote-store.hh

@@ -9,16 +9,37 @@ namespace nix {
 
 struct UDSRemoteStoreConfig : virtual LocalFSStoreConfig, virtual RemoteStoreConfig
 {
-    UDSRemoteStoreConfig(const Params & params)
+
+    static constexpr char const * scheme = "unix";
+
+    // TODO(fzakaria): Delete this constructor once moved over to the factory pattern
+    // outlined in https://github.com/NixOS/nix/issues/10766
+    using LocalFSStoreConfig::LocalFSStoreConfig;
+    using RemoteStoreConfig::RemoteStoreConfig;
+
+    UDSRemoteStoreConfig(std::string_view scheme, std::string_view authority, const Params & params)
         : StoreConfig(params)
         , LocalFSStoreConfig(params)
         , RemoteStoreConfig(params)
     {
+        assert(scheme == UDSRemoteStoreConfig::scheme && "Scheme must be 'unix'");
+        if (!authority.empty()) {
+            path.emplace(authority);
+        }
     }
 
     const std::string name() override { return "Local Daemon Store"; }
 
     std::string doc() override;
+
+    /**
+     * The path to the unix domain socket.
+     *
+     * The default *could be* settings.nixDaemonSocketFile but that
+     * won't pick up live changes unfortunately. This optional handling is instead
+     * handled on opening of the connection.
+     */
+    std::optional<std::string> path;
 };
 
 class UDSRemoteStore : public virtual UDSRemoteStoreConfig
@@ -27,16 +48,16 @@ class UDSRemoteStore : public virtual UDSRemoteStoreConfig
 {
 public:
 
-    UDSRemoteStore(const Params & params);
     UDSRemoteStore(
         std::string_view scheme,
-        PathView path,
+        // authority is the socket path
+        std::string_view authority,
         const Params & params);
 
     std::string getUri() override;
 
     static std::set<std::string> uriSchemes()
-    { return {"unix"}; }
+    { return {scheme}; }
 
     ref<SourceAccessor> getFSAccessor(bool requireValidPath = true) override
     { return LocalFSStore::getFSAccessor(requireValidPath); }
@@ -63,7 +84,8 @@ private:
     };
 
     ref<RemoteStore::Connection> openConnection() override;
-    std::optional<std::string> path;
+
+    std::string getPathOrDefault() const;
 };
 
 }