Factor out abstract syntax for Store URIs

Need to decouple parsing from actually opening a store for Machine
configs.

Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
Co-authored-by: Robert Hensing <roberth@users.noreply.github.com>

src/libstore/store-api.cc

@@ -8,7 +8,6 @@
 #include "util.hh"
 #include "nar-info-disk-cache.hh"
 #include "thread-pool.hh"
-#include "url.hh"
 #include "references.hh"
 #include "archive.hh"
 #include "callback.hh"
@@ -1267,34 +1266,18 @@ Derivation Store::readInvalidDerivation(const StorePath & drvPath)
 
 namespace nix {
 
-/* Split URI into protocol+hierarchy part and its parameter set. */
+ref<Store> openStore(const std::string & uri,
-std::pair<std::string, Store::Params> splitUriAndParams(const std::string & uri_)
+    const Store::Params & extraParams)
 {
-    auto uri(uri_);
+    return openStore(StoreReference::parse(uri, extraParams));
-    Store::Params params;
-    auto q = uri.find('?');
-    if (q != std::string::npos) {
-        params = decodeQuery(uri.substr(q + 1));
-        uri = uri_.substr(0, q);
-    }
-    return {uri, params};
 }
 
-static bool isNonUriPath(const std::string & spec)
+ref<Store> openStore(StoreReference && storeURI)
 {
-    return
+    auto & params = storeURI.params;
-        // is not a URL
-        spec.find("://") == std::string::npos
-        // Has at least one path separator, and so isn't a single word that
-        // might be special like "auto"
-        && spec.find("/") != std::string::npos;
-}
 
-std::shared_ptr<Store> openFromNonUri(const std::string & uri, const Store::Params & params)
+    auto store = std::visit(overloaded {
-{
+        [&](const StoreReference::Auto &) -> std::shared_ptr<Store> {
-    // TODO reenable on Windows once we have `LocalStore` and
-    // `UDSRemoteStore`.
-    if (uri == "" || uri == "auto") {
             auto stateDir = getOr(params, "state", settings.nixStateDir);
             if (access(stateDir.c_str(), R_OK | W_OK) == 0)
                 return std::make_shared<LocalStore>(params);
@@ -1325,51 +1308,21 @@ std::shared_ptr<Store> openFromNonUri(const std::string & uri, const Store::Para
             #endif
             else
                 return std::make_shared<LocalStore>(params);
-    } else if (uri == "daemon") {
+        },
-        return std::make_shared<UDSRemoteStore>(params);
+        [&](const StoreReference::Specified & g) {
-    } else if (uri == "local") {
+            for (auto implem : *Implementations::registered)
-        return std::make_shared<LocalStore>(params);
+                if (implem.uriSchemes.count(g.scheme))
-    } else if (isNonUriPath(uri)) {
+                    return implem.create(g.scheme, g.authority, params);
-        return std::make_shared<LocalStore>("local", absPath(uri), params);
-    } else {
-        return nullptr;
-    }
-}
 
-ref<Store> openStore(const std::string & uri_,
+            throw Error("don't know how to open Nix store with scheme '%s'", g.scheme);
-    const Store::Params & extraParams)
+        },
-{
+    }, storeURI.variant);
-    auto params = extraParams;
-    try {
-        auto parsedUri = parseURL(uri_);
-        params.insert(parsedUri.query.begin(), parsedUri.query.end());
 
-        auto baseURI = parsedUri.authority.value_or("") + parsedUri.path;
-
-        for (auto implem : *Implementations::registered) {
-            if (implem.uriSchemes.count(parsedUri.scheme)) {
-                auto store = implem.create(parsedUri.scheme, baseURI, params);
-                if (store) {
     experimentalFeatureSettings.require(store->experimentalFeature());
+    store->warnUnknownSettings();
     store->init();
-                    store->warnUnknownSettings();
-                    return ref<Store>(store);
-                }
-            }
-        }
-    }
-    catch (BadURL &) {
-        auto [uri, uriParams] = splitUriAndParams(uri_);
-        params.insert(uriParams.begin(), uriParams.end());
 
-        if (auto store = openFromNonUri(uri, params)) {
+    return ref<Store> { store };
-            experimentalFeatureSettings.require(store->experimentalFeature());
-            store->warnUnknownSettings();
-            return ref<Store>(store);
-        }
-    }
-
-    throw Error("don't know how to open Nix store '%s'", uri_);
 }
 
 std::list<ref<Store>> getDefaultSubstituters()

src/libstore/store-api.hh

@@ -13,6 +13,7 @@
 #include "path-info.hh"
 #include "repair-flag.hh"
 #include "store-dir-config.hh"
+#include "store-reference.hh"
 #include "source-path.hh"
 
 #include <nlohmann/json_fwd.hpp>
@@ -65,7 +66,7 @@ MakeError(Unsupported, Error);
 MakeError(SubstituteGone, Error);
 MakeError(SubstituterDisabled, Error);
 
-MakeError(InvalidStoreURI, Error);
+MakeError(InvalidStoreReference, Error);
 
 struct Realisation;
 struct RealisedPath;
@@ -102,7 +103,7 @@ typedef std::map<StorePath, std::optional<ContentAddress>> StorePathCAMap;
 
 struct StoreConfig : public StoreDirConfig
 {
-    typedef std::map<std::string, std::string> Params;
+    using Params = StoreReference::Params;
 
     using StoreDirConfig::StoreDirConfig;
 
@@ -859,34 +860,13 @@ OutputPathMap resolveDerivedPath(Store &, const DerivedPath::Built &, Store * ev
 /**
  * @return a Store object to access the Nix store denoted by
  * ‘uri’ (slight misnomer...).
- *
+ */
- * @param uri Supported values are:
+ref<Store> openStore(StoreReference && storeURI);
- *
+
- * - ‘local’: The Nix store in /nix/store and database in
+
- *   /nix/var/nix/db, accessed directly.
+/**
- *
+ * Opens the store at `uri`, where `uri` is in the format expected by `StoreReference::parse`
- * - ‘daemon’: The Nix store accessed via a Unix domain socket
+
- *   connection to nix-daemon.
- *
- * - ‘unix://<path>’: The Nix store accessed via a Unix domain socket
- *   connection to nix-daemon, with the socket located at <path>.
- *
- * - ‘auto’ or ‘’: Equivalent to ‘local’ or ‘daemon’ depending on
- *   whether the user has write access to the local Nix
- *   store/database.
- *
- * - ‘file://<path>’: A binary cache stored in <path>.
- *
- * - ‘https://<path>’: A binary cache accessed via HTTP.
- *
- * - ‘s3://<path>’: A writable binary cache stored on Amazon's Simple
- *   Storage Service.
- *
- * - ‘ssh://[user@]<host>’: A remote Nix store accessed by running
- *   ‘nix-store --serve’ via SSH.
- *
- * You can pass parameters to the store type by appending
- * ‘?key=value&key=value&...’ to the URI.
  */
 ref<Store> openStore(const std::string & uri = settings.storeUri.get(),
     const Store::Params & extraParams = Store::Params());
@@ -957,11 +937,6 @@ std::optional<ValidPathInfo> decodeValidPathInfo(
     std::istream & str,
     std::optional<HashResult> hashGiven = std::nullopt);
 
-/**
- * Split URI into protocol+hierarchy part and its parameter set.
- */
-std::pair<std::string, Store::Params> splitUriAndParams(const std::string & uri);
-
 const ContentAddress * getDerivationCA(const BasicDerivation & drv);
 
 std::map<DrvOutput, StorePath> drvOutputReferences(

src/libstore/store-reference.cc

@@ -0,0 +1,92 @@
+#include <regex>
+
+#include "error.hh"
+#include "url.hh"
+#include "store-reference.hh"
+#include "file-system.hh"
+
+namespace nix {
+
+static bool isNonUriPath(const std::string & spec)
+{
+    return
+        // is not a URL
+        spec.find("://") == std::string::npos
+        // Has at least one path separator, and so isn't a single word that
+        // might be special like "auto"
+        && spec.find("/") != std::string::npos;
+}
+
+StoreReference StoreReference::parse(const std::string & uri, const StoreReference::Params & extraParams)
+{
+    auto params = extraParams;
+    try {
+        auto parsedUri = parseURL(uri);
+        params.insert(parsedUri.query.begin(), parsedUri.query.end());
+
+        auto baseURI = parsedUri.authority.value_or("") + parsedUri.path;
+
+        return {
+            .variant =
+                Specified{
+                    .scheme = std::move(parsedUri.scheme),
+                    .authority = std::move(baseURI),
+                },
+            .params = std::move(params),
+        };
+    } catch (BadURL &) {
+        auto [baseURI, uriParams] = splitUriAndParams(uri);
+        params.insert(uriParams.begin(), uriParams.end());
+
+        if (baseURI == "" || baseURI == "auto") {
+            return {
+                .variant = Auto{},
+                .params = std::move(params),
+            };
+        } else if (baseURI == "daemon") {
+            return {
+                .variant =
+                    Specified{
+                        .scheme = "unix",
+                        .authority = "",
+                    },
+                .params = std::move(params),
+            };
+        } else if (baseURI == "local") {
+            return {
+                .variant =
+                    Specified{
+                        .scheme = "local",
+                        .authority = "",
+                    },
+                .params = std::move(params),
+            };
+        } else if (isNonUriPath(baseURI)) {
+            return {
+                .variant =
+                    Specified{
+                        .scheme = "local",
+                        .authority = absPath(baseURI),
+                    },
+                .params = std::move(params),
+            };
+        }
+    }
+
+    throw UsageError("Cannot parse Nix store '%s'", uri);
+}
+
+/* Split URI into protocol+hierarchy part and its parameter set. */
+std::pair<std::string, StoreReference::Params> splitUriAndParams(const std::string & uri_)
+{
+    auto uri(uri_);
+    StoreReference::Params params;
+    auto q = uri.find('?');
+    if (q != std::string::npos) {
+        params = decodeQuery(uri.substr(q + 1));
+        uri = uri_.substr(0, q);
+    }
+    return {uri, params};
+}
+
+}

src/libstore/store-reference.hh

@@ -0,0 +1,84 @@
+#pragma once
+///@file
+
+#include <variant>
+
+#include "types.hh"
+
+namespace nix {
+
+/**
+ * A parsed Store URI (URI is a slight misnomer...), parsed but not yet
+ * resolved to a specific instance and query parms validated.
+ *
+ * Supported values are:
+ *
+ * - ‘local’: The Nix store in /nix/store and database in
+ *   /nix/var/nix/db, accessed directly.
+ *
+ * - ‘daemon’: The Nix store accessed via a Unix domain socket
+ *   connection to nix-daemon.
+ *
+ * - ‘unix://<path>’: The Nix store accessed via a Unix domain socket
+ *   connection to nix-daemon, with the socket located at <path>.
+ *
+ * - ‘auto’ or ‘’: Equivalent to ‘local’ or ‘daemon’ depending on
+ *   whether the user has write access to the local Nix
+ *   store/database.
+ *
+ * - ‘file://<path>’: A binary cache stored in <path>.
+ *
+ * - ‘https://<path>’: A binary cache accessed via HTTP.
+ *
+ * - ‘s3://<path>’: A writable binary cache stored on Amazon's Simple
+ *   Storage Service.
+ *
+ * - ‘ssh://[user@]<host>’: A remote Nix store accessed by running
+ *   ‘nix-store --serve’ via SSH.
+ *
+ * You can pass parameters to the store type by appending
+ * ‘?key=value&key=value&...’ to the URI.
+ */
+struct StoreReference
+{
+    using Params = std::map<std::string, std::string>;
+
+    /**
+     * Special store reference `""` or `"auto"`
+     */
+    struct Auto
+    {
+        inline bool operator==(const Auto & rhs) const = default;
+        inline auto operator<=>(const Auto & rhs) const = default;
+    };
+
+    /**
+     * General case, a regular `scheme://authority` URL.
+     */
+    struct Specified
+    {
+        std::string scheme;
+        std::string authority;
+
+        bool operator==(const Specified & rhs) const = default;
+        auto operator<=>(const Specified & rhs) const = default;
+    };
+
+    typedef std::variant<Auto, Specified> Variant;
+
+    Variant variant;
+
+    Params params;
+
+    bool operator==(const StoreReference & rhs) const = default;
+    auto operator<=>(const StoreReference & rhs) const = default;
+
+    static StoreReference parse(const std::string & uri, const Params & extraParams = Params{});
+};
+
+/**
+ * Split URI into protocol+hierarchy part and its parameter set.
+ */
+std::pair<std::string, StoreReference::Params> splitUriAndParams(const std::string & uri);
+
+}