Merge remote-tracking branch 'upstream/master' into path-info

src/libstore/store-api.cc

@@ -1228,117 +1228,6 @@ std::string showPaths(const PathSet & paths)
     return concatStringsSep(", ", quoteStrings(paths));
 }
 
-std::string ValidPathInfo::fingerprint(const Store & store) const
-{
-    if (narSize == 0)
-        throw Error("cannot calculate fingerprint of path '%s' because its size is not known",
-            store.printStorePath(path));
-    return
-        "1;" + store.printStorePath(path) + ";"
-        + narHash.to_string(Base32, true) + ";"
-        + std::to_string(narSize) + ";"
-        + concatStringsSep(",", store.printStorePathSet(referencesPossiblyToSelf()));
-}
-
-
-void ValidPathInfo::sign(const Store & store, const SecretKey & secretKey)
-{
-    sigs.insert(secretKey.signDetached(fingerprint(store)));
-}
-
-std::optional<StorePathDescriptor> ValidPathInfo::fullStorePathDescriptorOpt() const
-{
-    if (! ca)
-        return std::nullopt;
-
-    return StorePathDescriptor {
-        .name = std::string { path.name() },
-        .info = std::visit(overloaded {
-            [&](const TextHash & th) -> ContentAddressWithReferences {
-                assert(!references.self);
-                return TextInfo {
-                    th,
-                    .references = references.others,
-                };
-            },
-            [&](const FixedOutputHash & foh) -> ContentAddressWithReferences {
-                return FixedOutputInfo {
-                    foh,
-                    .references = references,
-                };
-            },
-        }, *ca),
-    };
-}
-
-bool ValidPathInfo::isContentAddressed(const Store & store) const
-{
-    auto fullCaOpt = fullStorePathDescriptorOpt();
-
-    if (! fullCaOpt)
-        return false;
-
-    auto caPath = store.makeFixedOutputPathFromCA(*fullCaOpt);
-
-    bool res = caPath == path;
-
-    if (!res)
-        printError("warning: path '%s' claims to be content-addressed but isn't", store.printStorePath(path));
-
-    return res;
-}
-
-
-size_t ValidPathInfo::checkSignatures(const Store & store, const PublicKeys & publicKeys) const
-{
-    if (isContentAddressed(store)) return maxSigs;
-
-    size_t good = 0;
-    for (auto & sig : sigs)
-        if (checkSignature(store, publicKeys, sig))
-            good++;
-    return good;
-}
-
-
-bool ValidPathInfo::checkSignature(const Store & store, const PublicKeys & publicKeys, const std::string & sig) const
-{
-    return verifyDetached(fingerprint(store), sig, publicKeys);
-}
-
-
-Strings ValidPathInfo::shortRefs() const
-{
-    Strings refs;
-    for (auto & r : referencesPossiblyToSelf())
-        refs.push_back(std::string(r.to_string()));
-    return refs;
-}
-
-
-ValidPathInfo::ValidPathInfo(
-    const Store & store,
-    StorePathDescriptor && info,
-    Hash narHash)
-      : path(store.makeFixedOutputPathFromCA(info))
-      , narHash(narHash)
-{
-    std::visit(overloaded {
-        [this](TextInfo && ti) {
-            this->references = {
-                .others = std::move(ti.references),
-                .self = false,
-            };
-            this->ca = std::move((TextHash &&) ti);
-        },
-        [this](FixedOutputInfo && foi) {
-            this->references = std::move(foi.references);
-            this->ca = std::move((FixedOutputHash &&) foi);
-        },
-    }, std::move(info.info));
-}
-
-
 Derivation Store::derivationFromPath(const StorePath & drvPath)
 {
     ensurePath(drvPath);
@@ -1357,6 +1246,34 @@ Derivation readDerivationCommon(Store& store, const StorePath& drvPath, bool req
     }
 }
 
+std::optional<StorePath> Store::getBuildDerivationPath(const StorePath & path)
+{
+
+    if (!path.isDerivation()) {
+        try {
+            auto info = queryPathInfo(path);
+            if (!info->deriver) return std::nullopt;
+            return *info->deriver;
+        } catch (InvalidPath &) {
+            return std::nullopt;
+        }
+    }
+
+    if (!settings.isExperimentalFeatureEnabled(Xp::CaDerivations) || !isValidPath(path))
+        return path;
+
+    auto drv = readDerivation(path);
+    if (!drv.type().hasKnownOutputPaths()) {
+        // The build log is actually attached to the corresponding
+        // resolved derivation, so we need to get it first
+        auto resolvedDrv = drv.tryResolve(*this);
+        if (resolvedDrv)
+            return writeDerivation(*this, *resolvedDrv, NoRepair, true);
+    }
+
+    return path;
+}
+
 Derivation Store::readDerivation(const StorePath & drvPath)
 { return readDerivationCommon(*this, drvPath, true); }