From 59979e705352abb1624d3427c2c7145ed43b1b84 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Mon, 24 Aug 2020 18:10:58 +0000
Subject: [PATCH 01/11] Fix bad debug format string

---
 src/libstore/build.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index ba28e78c8..6baaa31d9 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -3850,7 +3850,7 @@ void DerivationGoal::registerOutputs()
            something like that. */
         canonicalisePathMetaData(actualPath, buildUser ? buildUser->getUID() : -1, inodesSeen);
 
-        debug("scanning for references for output %1 in temp location '%1%'", outputName, actualPath);
+        debug("scanning for references for output '%s' in temp location '%s'", outputName, actualPath);
 
         /* Pass blank Sink as we are not ready to hash data at this stage. */
         NullSink blank;

From e0b0e18905835fdc8ccbbf1c0f5d016d9f466187 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Sun, 23 Aug 2020 15:27:30 +0000
Subject: [PATCH 02/11] Add constructor for BasicDerivation -> Derivation

---
 src/libstore/derivations.hh | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index b09480e1e..2ea4178c0 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -100,7 +100,7 @@ struct BasicDerivation
     StringPairs env;
     std::string name;
 
-    BasicDerivation() { }
+    BasicDerivation() = default;
     virtual ~BasicDerivation() { };
 
     bool isBuiltin() const;
@@ -127,7 +127,8 @@ struct Derivation : BasicDerivation
     std::string unparse(const Store & store, bool maskOutputs,
         std::map<std::string, StringSet> * actualInputs = nullptr) const;
 
-    Derivation() { }
+    Derivation() = default;
+    Derivation(BasicDerivation && bd) : BasicDerivation(std::move(bd)) { }
 };
 
 

From 8eb73a87245acf9d93dc401831b629981864fa58 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Sat, 22 Aug 2020 20:44:47 +0000
Subject: [PATCH 03/11] CA derivations that depend on other CA derivations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Théophane Hufschmitt <regnat@users.noreply.github.com>
---
 src/libstore/build.cc       | 51 +++++++++++++++++++++++++++++++----
 src/libstore/derivations.cc | 53 +++++++++++++++++++++++++++++++++++++
 src/libstore/derivations.hh | 18 +++++++++++++
 src/libstore/local-store.cc | 27 +++++++++++++++++--
 tests/content-addressed.nix | 48 ++++++++++++++++++++++++---------
 tests/content-addressed.sh  | 20 +++++++-------
 6 files changed, 189 insertions(+), 28 deletions(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index 6baaa31d9..f5256bf87 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -984,6 +984,8 @@ private:
     void tryLocalBuild();
     void buildDone();
 
+    void resolvedFinished();
+
     /* Is the build hook willing to perform the build? */
     HookReply tryBuildHook();
 
@@ -1451,8 +1453,39 @@ void DerivationGoal::inputsRealised()
     /* Determine the full set of input paths. */
 
     /* First, the input derivations. */
-    if (useDerivation)
-        for (auto & [depDrvPath, wantedDepOutputs] : dynamic_cast<Derivation *>(drv.get())->inputDrvs) {
+    if (useDerivation) {
+        auto & fullDrv = *dynamic_cast<Derivation *>(drv.get());
+
+        if (!fullDrv.inputDrvs.empty() && fullDrv.type() == DerivationType::CAFloating) {
+            /* We are be able to resolve this derivation based on the
+               now-known results of dependencies. If so, we become a stub goal
+               aliasing that resolved derivation goal */
+            Derivation drvResolved { fullDrv.resolve(worker.store) };
+
+            auto pathResolved = writeDerivation(worker.store, drvResolved);
+            /* Add to memotable to speed up downstream goal's queries with the
+               original derivation. */
+            drvPathResolutions.lock()->insert_or_assign(drvPath, pathResolved);
+
+            auto msg = fmt("Resolved derivation: '%s' -> '%s'",
+                worker.store.printStorePath(drvPath),
+                worker.store.printStorePath(pathResolved));
+            act = std::make_unique<Activity>(*logger, lvlInfo, actBuildWaiting, msg,
+                Logger::Fields {
+                       worker.store.printStorePath(drvPath),
+                       worker.store.printStorePath(pathResolved),
+                   });
+
+            auto resolvedGoal = worker.makeDerivationGoal(
+                pathResolved, wantedOutputs,
+                buildMode == bmRepair ? bmRepair : bmNormal);
+            addWaitee(resolvedGoal);
+
+            state = &DerivationGoal::resolvedFinished;
+            return;
+        }
+
+        for (auto & [depDrvPath, wantedDepOutputs] : fullDrv.inputDrvs) {
             /* Add the relevant output closures of the input derivation
                `i' as input paths.  Only add the closures of output paths
                that are specified as inputs. */
@@ -1472,6 +1505,7 @@ void DerivationGoal::inputsRealised()
                         worker.store.printStorePath(drvPath), j, worker.store.printStorePath(drvPath));
             }
         }
+    }
 
     /* Second, the input sources. */
     worker.store.computeFSClosure(drv->inputSrcs, inputPaths);
@@ -1893,6 +1927,9 @@ void DerivationGoal::buildDone()
     done(BuildResult::Built);
 }
 
+void DerivationGoal::resolvedFinished() {
+    done(BuildResult::Built);
+}
 
 HookReply DerivationGoal::tryBuildHook()
 {
@@ -2065,7 +2102,7 @@ void linkOrCopy(const Path & from, const Path & to)
            file (e.g. 32000 of ext3), which is quite possible after a
            'nix-store --optimise'. FIXME: actually, why don't we just
            bind-mount in this case?
-           
+
            It can also fail with EPERM in BeegFS v7 and earlier versions
            which don't allow hard-links to other directories */
         if (errno != EMLINK && errno != EPERM)
@@ -4248,10 +4285,14 @@ void DerivationGoal::registerOutputs()
     {
         ValidPathInfos infos2;
         for (auto & [outputName, newInfo] : infos) {
-            /* FIXME: we will want to track this mapping in the DB whether or
-               not we have a drv file. */
             if (useDerivation)
                 worker.store.linkDeriverToPath(drvPath, outputName, newInfo.path);
+            else {
+                /* Once a floating CA derivations reaches this point, it must
+                   already be resolved, drvPath the basic derivation path, and
+                   a file existsing at that path for sake of the DB's foreign key. */
+                assert(drv->type() != DerivationType::CAFloating);
+            }
             infos2.push_back(newInfo);
         }
         worker.store.registerValidPaths(infos2);
diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc
index 34541227b..d96d4083d 100644
--- a/src/libstore/derivations.cc
+++ b/src/libstore/derivations.cc
@@ -672,4 +672,57 @@ std::string downstreamPlaceholder(const Store & store, const StorePath & drvPath
     return "/" + hashString(htSHA256, clearText).to_string(Base32, false);
 }
 
+
+// N.B. Outputs are left unchanged
+static void rewriteDerivation(Store & store, BasicDerivation & drv, const StringMap & rewrites) {
+
+    debug("Rewriting the derivation");
+
+    for (auto &rewrite: rewrites) {
+        debug("rewriting %s as %s", rewrite.first, rewrite.second);
+    }
+
+    drv.builder = rewriteStrings(drv.builder, rewrites);
+    for (auto & arg: drv.args) {
+        arg = rewriteStrings(arg, rewrites);
+    }
+
+    StringPairs newEnv;
+    for (auto & envVar: drv.env) {
+        auto envName = rewriteStrings(envVar.first, rewrites);
+        auto envValue = rewriteStrings(envVar.second, rewrites);
+        newEnv.emplace(envName, envValue);
+    }
+    drv.env = newEnv;
+}
+
+
+Sync<DrvPathResolutions> drvPathResolutions;
+
+BasicDerivation Derivation::resolve(Store & store) {
+    BasicDerivation resolved { *this };
+
+    // Input paths that we'll want to rewrite in the derivation
+    StringMap inputRewrites;
+
+    for (auto & input : inputDrvs) {
+        auto inputDrvOutputs = store.queryPartialDerivationOutputMap(input.first);
+        StringSet newOutputNames;
+        for (auto & outputName : input.second) {
+            auto actualPathOpt = inputDrvOutputs.at(outputName);
+            if (!actualPathOpt)
+                throw Error("input drv '%s' wasn't yet built", store.printStorePath(input.first));
+            auto actualPath = *actualPathOpt;
+            inputRewrites.emplace(
+                downstreamPlaceholder(store, input.first, outputName),
+                store.printStorePath(actualPath));
+            resolved.inputSrcs.insert(std::move(actualPath));
+        }
+    }
+
+    rewriteDerivation(store, resolved, inputRewrites);
+
+    return resolved;
+}
+
 }
diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index 2ea4178c0..0bb565e8a 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -4,6 +4,7 @@
 #include "types.hh"
 #include "hash.hh"
 #include "content-address.hh"
+#include "sync.hh"
 
 #include <map>
 #include <variant>
@@ -127,6 +128,13 @@ struct Derivation : BasicDerivation
     std::string unparse(const Store & store, bool maskOutputs,
         std::map<std::string, StringSet> * actualInputs = nullptr) const;
 
+    /* Return the underlying basic derivation but with
+
+       1. input drv outputs moved to input sources.
+
+       2. placeholders replaced with realized input store paths. */
+    BasicDerivation resolve(Store & store);
+
     Derivation() = default;
     Derivation(BasicDerivation && bd) : BasicDerivation(std::move(bd)) { }
 };
@@ -187,6 +195,16 @@ typedef std::map<StorePath, DrvHashModulo> DrvHashes;
 
 extern DrvHashes drvHashes; // FIXME: global, not thread-safe
 
+/* Memoisation of `readDerivation(..).resove()`. */
+typedef std::map<
+    StorePath,
+    std::optional<StorePath>
+> DrvPathResolutions;
+
+// FIXME: global, though at least thread-safe.
+// FIXME: arguably overlaps with hashDerivationModulo memo table.
+extern Sync<DrvPathResolutions> drvPathResolutions;
+
 bool wantOutput(const string & output, const std::set<string> & wanted);
 
 struct Source;
diff --git a/src/libstore/local-store.cc b/src/libstore/local-store.cc
index 0086bb13e..e51d127b3 100644
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -803,13 +803,36 @@ StorePathSet LocalStore::queryValidDerivers(const StorePath & path)
 }
 
 
-std::map<std::string, std::optional<StorePath>> LocalStore::queryPartialDerivationOutputMap(const StorePath & path)
+std::map<std::string, std::optional<StorePath>> LocalStore::queryPartialDerivationOutputMap(const StorePath & path_)
 {
+    auto path = path_;
     std::map<std::string, std::optional<StorePath>> outputs;
-    BasicDerivation drv = readDerivation(path);
+    Derivation drv = readDerivation(path);
     for (auto & [outName, _] : drv.outputs) {
         outputs.insert_or_assign(outName, std::nullopt);
     }
+    bool haveCached = false;
+    {
+        auto resolutions = drvPathResolutions.lock();
+        auto resolvedPathOptIter = resolutions->find(path);
+        if (resolvedPathOptIter != resolutions->end()) {
+            auto & [_, resolvedPathOpt] = *resolvedPathOptIter;
+            if (resolvedPathOpt)
+                path = *resolvedPathOpt;
+            haveCached = true;
+        }
+    }
+    /* can't just use else-if instead of `!haveCached` because we need to unlock
+       `drvPathResolutions` before it is locked in `Derivation::resolve`. */
+    if (!haveCached && drv.type() == DerivationType::CAFloating) {
+        /* Resolve drv and use that path instead. */
+        auto pathResolved = writeDerivation(*this, drv.resolve(*this));
+        /* Store in memo table. */
+        /* FIXME: memo logic should not be local-store specific, should have
+           wrapper-method instead. */
+        drvPathResolutions.lock()->insert_or_assign(path, pathResolved);
+        path = std::move(pathResolved);
+    }
     return retrySQLite<std::map<std::string, std::optional<StorePath>>>([&]() {
         auto state(_state.lock());
 
diff --git a/tests/content-addressed.nix b/tests/content-addressed.nix
index 586e4cba6..a46c21164 100644
--- a/tests/content-addressed.nix
+++ b/tests/content-addressed.nix
@@ -4,16 +4,40 @@ with import ./config.nix;
 # A simple content-addressed derivation.
 # The derivation can be arbitrarily modified by passing a different `seed`,
 # but the output will always be the same
-mkDerivation {
-  name = "simple-content-addressed";
-  buildCommand = ''
-    set -x
-    echo "Building a CA derivation"
-    echo "The seed is ${toString seed}"
-    mkdir -p $out
-    echo "Hello World" > $out/hello
-  '';
-  __contentAddressed = true;
-  outputHashMode = "recursive";
-  outputHashAlgo = "sha256";
+rec {
+  root = mkDerivation {
+    name = "simple-content-addressed";
+    buildCommand = ''
+      set -x
+      echo "Building a CA derivation"
+      echo "The seed is ${toString seed}"
+      mkdir -p $out
+      echo "Hello World" > $out/hello
+    '';
+    __contentAddressed = true;
+    outputHashMode = "recursive";
+    outputHashAlgo = "sha256";
+  };
+  dependent = mkDerivation {
+    name = "dependent";
+    buildCommand = ''
+      echo "building a dependent derivation"
+      mkdir -p $out
+      echo ${root}/hello > $out/dep
+    '';
+    __contentAddressed = true;
+    outputHashMode = "recursive";
+    outputHashAlgo = "sha256";
+  };
+  transitivelyDependent = mkDerivation {
+    name = "transitively-dependent";
+    buildCommand = ''
+      echo "building transitively-dependent"
+      cat ${dependent}/dep
+      echo ${dependent} > $out
+    '';
+    __contentAddressed = true;
+    outputHashMode = "recursive";
+    outputHashAlgo = "sha256";
+  };
 }
diff --git a/tests/content-addressed.sh b/tests/content-addressed.sh
index 2968f3a8c..522310585 100644
--- a/tests/content-addressed.sh
+++ b/tests/content-addressed.sh
@@ -2,15 +2,17 @@
 
 source common.sh
 
-clearStore
-clearCache
-
-export REMOTE_STORE=file://$cacheDir
-
-drv=$(nix-instantiate --experimental-features ca-derivations ./content-addressed.nix --arg seed 1)
+drv=$(nix-instantiate --experimental-features ca-derivations ./content-addressed.nix -A root --arg seed 1)
 nix --experimental-features 'nix-command ca-derivations' show-derivation --derivation "$drv" --arg seed 1
 
-out1=$(nix-build --experimental-features ca-derivations ./content-addressed.nix --arg seed 1 --no-out-link)
-out2=$(nix-build --experimental-features ca-derivations ./content-addressed.nix --arg seed 2 --no-out-link)
+testDerivation () {
+    local derivationPath=$1
+    local commonArgs=("--experimental-features" "ca-derivations" "./content-addressed.nix" "-A" "$derivationPath" "--no-out-link")
+    local out1=$(nix-build "${commonArgs[@]}" --arg seed 1)
+    local out2=$(nix-build "${commonArgs[@]}" --arg seed 2)
+    test $out1 == $out2
+}
 
-test $out1 == $out2
+testDerivation root
+testDerivation dependent
+testDerivation transitivelyDependent

From 421ed527c70201c722cbefc10576ae77e383ba8e Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Fri, 28 Aug 2020 17:22:57 -0400
Subject: [PATCH 04/11] Update src/libstore/build.cc

Thanks for catching, @regnat.
---
 src/libstore/build.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index f5256bf87..1249668c4 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -1477,8 +1477,7 @@ void DerivationGoal::inputsRealised()
                    });
 
             auto resolvedGoal = worker.makeDerivationGoal(
-                pathResolved, wantedOutputs,
-                buildMode == bmRepair ? bmRepair : bmNormal);
+                pathResolved, wantedOutputs, buildMode);
             addWaitee(resolvedGoal);
 
             state = &DerivationGoal::resolvedFinished;

From 4db0010a9374e357de3db3c0cf1cb1b490a14727 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Fri, 28 Aug 2020 22:03:54 +0000
Subject: [PATCH 05/11] Test CA derivation input caching

---
 tests/content-addressed.sh | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/content-addressed.sh b/tests/content-addressed.sh
index 522310585..5997a432f 100644
--- a/tests/content-addressed.sh
+++ b/tests/content-addressed.sh
@@ -9,10 +9,13 @@ testDerivation () {
     local derivationPath=$1
     local commonArgs=("--experimental-features" "ca-derivations" "./content-addressed.nix" "-A" "$derivationPath" "--no-out-link")
     local out1=$(nix-build "${commonArgs[@]}" --arg seed 1)
-    local out2=$(nix-build "${commonArgs[@]}" --arg seed 2)
+    local out2=$(nix-build "${commonArgs[@]}" --arg seed 2 "${extraArgs[@]}")
     test $out1 == $out2
 }
 
 testDerivation root
+# The seed only changes the root derivation, and not it's output, so the
+# dependent derivations should only need to be built once.
+extaArgs=(-j0)
 testDerivation dependent
 testDerivation transitivelyDependent

From aad4abcc9c27d5c1a2349e40f51f076387e0f844 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Fri, 4 Sep 2020 01:17:38 +0000
Subject: [PATCH 06/11] Fix floating CA tests

We will sometimes try to query the outputs of derivations we can't
resolve. That's fine; it just means we don't know what those outputs are
yet.
---
 src/libstore/build.cc       | 4 +++-
 src/libstore/derivations.cc | 4 ++--
 src/libstore/derivations.hh | 2 +-
 src/libstore/local-store.cc | 9 +++++++--
 tests/content-addressed.sh  | 2 +-
 5 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index 1249668c4..1f77b8ea8 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -1460,7 +1460,9 @@ void DerivationGoal::inputsRealised()
             /* We are be able to resolve this derivation based on the
                now-known results of dependencies. If so, we become a stub goal
                aliasing that resolved derivation goal */
-            Derivation drvResolved { fullDrv.resolve(worker.store) };
+            std::optional attempt = fullDrv.tryResolve(worker.store);
+            assert(attempt);
+            Derivation drvResolved { *std::move(attempt) };
 
             auto pathResolved = writeDerivation(worker.store, drvResolved);
             /* Add to memotable to speed up downstream goal's queries with the
diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc
index ce57a5bb0..695265860 100644
--- a/src/libstore/derivations.cc
+++ b/src/libstore/derivations.cc
@@ -671,7 +671,7 @@ static void rewriteDerivation(Store & store, BasicDerivation & drv, const String
 
 Sync<DrvPathResolutions> drvPathResolutions;
 
-BasicDerivation Derivation::resolve(Store & store) {
+std::optional<BasicDerivation> Derivation::tryResolve(Store & store) {
     BasicDerivation resolved { *this };
 
     // Input paths that we'll want to rewrite in the derivation
@@ -683,7 +683,7 @@ BasicDerivation Derivation::resolve(Store & store) {
         for (auto & outputName : input.second) {
             auto actualPathOpt = inputDrvOutputs.at(outputName);
             if (!actualPathOpt)
-                throw Error("input drv '%s' wasn't yet built", store.printStorePath(input.first));
+                return std::nullopt;
             auto actualPath = *actualPathOpt;
             inputRewrites.emplace(
                 downstreamPlaceholder(store, input.first, outputName),
diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index e4d85aa05..eaffbf452 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -133,7 +133,7 @@ struct Derivation : BasicDerivation
        1. input drv outputs moved to input sources.
 
        2. placeholders replaced with realized input store paths. */
-    BasicDerivation resolve(Store & store);
+    std::optional<BasicDerivation> tryResolve(Store & store);
 
     Derivation() = default;
     Derivation(BasicDerivation && bd) : BasicDerivation(std::move(bd)) { }
diff --git a/src/libstore/local-store.cc b/src/libstore/local-store.cc
index e51d127b3..f490188ce 100644
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -825,8 +825,13 @@ std::map<std::string, std::optional<StorePath>> LocalStore::queryPartialDerivati
     /* can't just use else-if instead of `!haveCached` because we need to unlock
        `drvPathResolutions` before it is locked in `Derivation::resolve`. */
     if (!haveCached && drv.type() == DerivationType::CAFloating) {
-        /* Resolve drv and use that path instead. */
-        auto pathResolved = writeDerivation(*this, drv.resolve(*this));
+        /* Try resolve drv and use that path instead. */
+        auto attempt = drv.tryResolve(*this);
+        if (!attempt)
+            /* If we cannot resolve the derivation, we cannot have any path
+               assigned so we return the map of all std::nullopts. */
+            return outputs;
+        auto pathResolved = writeDerivation(*this, *std::move(attempt));
         /* Store in memo table. */
         /* FIXME: memo logic should not be local-store specific, should have
            wrapper-method instead. */
diff --git a/tests/content-addressed.sh b/tests/content-addressed.sh
index b2e94fe1e..34334b22d 100644
--- a/tests/content-addressed.sh
+++ b/tests/content-addressed.sh
@@ -9,7 +9,7 @@ testDerivation () {
     local derivationPath=$1
     local commonArgs=("--experimental-features" "ca-derivations" "./content-addressed.nix" "-A" "$derivationPath" "--no-out-link")
     local out1 out2
-    out1=$(set -e; nix-build "${commonArgs[@]}" --arg seed 1)
+    out1=$(nix-build "${commonArgs[@]}" --arg seed 1)
     out2=$(nix-build "${commonArgs[@]}" --arg seed 2 "${secondSeedArgs[@]}")
     test "$out1" == "$out2"
 }

From 98dfd7531d6df6abc925a446f390c4a5bbb9a51d Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Fri, 4 Sep 2020 18:33:58 +0000
Subject: [PATCH 07/11] Fix querying outputs for CA derivations some more

If we resolve using the known path of a derivation whose output we
didn't have, we previously blew up. Now we just fail gracefully,
returning the map of all outputs unknown.
---
 src/libstore/derivations.cc |  4 ++--
 src/libstore/derivations.hh |  4 +++-
 src/libstore/local-store.cc | 20 ++++++++++++++++----
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc
index 695265860..afac00fc4 100644
--- a/src/libstore/derivations.cc
+++ b/src/libstore/derivations.cc
@@ -69,7 +69,7 @@ bool BasicDerivation::isBuiltin() const
 
 
 StorePath writeDerivation(Store & store,
-    const Derivation & drv, RepairFlag repair)
+    const Derivation & drv, RepairFlag repair, bool readOnly)
 {
     auto references = drv.inputSrcs;
     for (auto & i : drv.inputDrvs)
@@ -79,7 +79,7 @@ StorePath writeDerivation(Store & store,
        held during a garbage collection). */
     auto suffix = std::string(drv.name) + drvExtension;
     auto contents = drv.unparse(store, false);
-    return settings.readOnlyMode
+    return readOnly || settings.readOnlyMode
         ? store.computeStorePathForText(suffix, contents, references)
         : store.addTextToStore(suffix, contents, references, repair);
 }
diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index 8aa496143..716862127 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -146,7 +146,9 @@ enum RepairFlag : bool { NoRepair = false, Repair = true };
 
 /* Write a derivation to the Nix store, and return its path. */
 StorePath writeDerivation(Store & store,
-    const Derivation & drv, RepairFlag repair = NoRepair);
+    const Derivation & drv,
+    RepairFlag repair = NoRepair,
+    bool readOnly = false);
 
 /* Read a derivation from a file. */
 Derivation parseDerivation(const Store & store, std::string && s, std::string_view name);
diff --git a/src/libstore/local-store.cc b/src/libstore/local-store.cc
index f490188ce..0755cfa91 100644
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -728,7 +728,7 @@ uint64_t LocalStore::queryValidPathId(State & state, const StorePath & path)
 {
     auto use(state.stmtQueryPathInfo.use()(printStorePath(path)));
     if (!use.next())
-        throw Error("path '%s' is not valid", printStorePath(path));
+        throw InvalidPath("path '%s' is not valid", printStorePath(path));
     return use.getInt(0);
 }
 
@@ -831,7 +831,8 @@ std::map<std::string, std::optional<StorePath>> LocalStore::queryPartialDerivati
             /* If we cannot resolve the derivation, we cannot have any path
                assigned so we return the map of all std::nullopts. */
             return outputs;
-        auto pathResolved = writeDerivation(*this, *std::move(attempt));
+        /* Just compute store path */
+        auto pathResolved = writeDerivation(*this, *std::move(attempt), NoRepair, true);
         /* Store in memo table. */
         /* FIXME: memo logic should not be local-store specific, should have
            wrapper-method instead. */
@@ -841,8 +842,19 @@ std::map<std::string, std::optional<StorePath>> LocalStore::queryPartialDerivati
     return retrySQLite<std::map<std::string, std::optional<StorePath>>>([&]() {
         auto state(_state.lock());
 
-        auto useQueryDerivationOutputs(state->stmtQueryDerivationOutputs.use()
-            (queryValidPathId(*state, path)));
+        uint64_t drvId;
+        try {
+            drvId = queryValidPathId(*state, path);
+        } catch (InvalidPath &) {
+            /* FIXME? if the derivation doesn't exist, we cannot have a mapping
+               for it. */
+            return outputs;
+        }
+
+        auto useQueryDerivationOutputs {
+            state->stmtQueryDerivationOutputs.use()
+            (drvId)
+        };
 
         while (useQueryDerivationOutputs.next())
             outputs.insert_or_assign(

From 7fdbb377ba800728a47095008cec11be7d970330 Mon Sep 17 00:00:00 2001
From: John Ericson <git@JohnEricson.me>
Date: Wed, 9 Sep 2020 14:55:43 -0400
Subject: [PATCH 08/11] Start to fix floating CA + remote building

---
 src/libstore/build.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index ee12f8e67..32980f264 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -4613,7 +4613,7 @@ void DerivationGoal::flushLine()
 
 std::map<std::string, std::optional<StorePath>> DerivationGoal::queryPartialDerivationOutputMap()
 {
-    if (drv->type() != DerivationType::CAFloating) {
+    if (!useDerivation || drv->type() != DerivationType::CAFloating) {
         std::map<std::string, std::optional<StorePath>> res;
         for (auto & [name, output] : drv->outputs)
             res.insert_or_assign(name, output.path(worker.store, drv->name, name));
@@ -4625,7 +4625,7 @@ std::map<std::string, std::optional<StorePath>> DerivationGoal::queryPartialDeri
 
 OutputPathMap DerivationGoal::queryDerivationOutputMap()
 {
-    if (drv->type() != DerivationType::CAFloating) {
+    if (!useDerivation || drv->type() != DerivationType::CAFloating) {
         OutputPathMap res;
         for (auto & [name, output] : drv->outputsAndOptPaths(worker.store))
             res.insert_or_assign(name, *output.second);

From 2741fffa350ec59d29ade24dd93007d535a61bde Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Wed, 9 Sep 2020 19:13:21 +0000
Subject: [PATCH 09/11] Ensure resolved CA derivations are written

so we can link outputs to deriver and thus properly cache.
---
 src/libstore/build.cc       | 33 ++++++++++++++++++++-------------
 src/libstore/derivations.hh |  1 +
 2 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index 32980f264..87c50f0e6 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -4298,11 +4298,13 @@ void DerivationGoal::registerOutputs()
     /* Register each output path as valid, and register the sets of
        paths referenced by each of them.  If there are cycles in the
        outputs, this will fail. */
-    ValidPathInfos infos2;
-    for (auto & [outputName, newInfo] : infos) {
-        infos2.push_back(newInfo);
+    {
+        ValidPathInfos infos2;
+        for (auto & [outputName, newInfo] : infos) {
+            infos2.push_back(newInfo);
+        }
+        worker.store.registerValidPaths(infos2);
     }
-    worker.store.registerValidPaths(infos2);
 
     /* In case of a fixed-output derivation hash mismatch, throw an
        exception now that we have registered the output as valid. */
@@ -4314,16 +4316,21 @@ void DerivationGoal::registerOutputs()
        means it's safe to link the derivation to the output hash. We must do
        that for floating CA derivations, which otherwise couldn't be cached,
        but it's fine to do in all cases. */
-    for (auto & [outputName, newInfo] : infos) {
-        if (useDerivation)
-            worker.store.linkDeriverToPath(drvPath, outputName, newInfo.path);
-        else {
-            /* Once a floating CA derivations reaches this point, it must
-               already be resolved, drvPath the basic derivation path, and
-               a file existsing at that path for sake of the DB's foreign key. */
-            assert(drv->type() != DerivationType::CAFloating);
-        }
+    bool isCaFloating = drv->type() == DerivationType::CAFloating;
+
+    auto drvPath2 = drvPath;
+    if (!useDerivation && isCaFloating) {
+        /* Once a floating CA derivations reaches this point, it
+           must already be resolved, so we don't bother trying to
+           downcast drv to get would would just be an empty
+           inputDrvs field. */
+        Derivation drv2 { *drv };
+        drvPath2 = writeDerivation(worker.store, drv2);
     }
+
+    if (useDerivation || isCaFloating)
+        for (auto & [outputName, newInfo] : infos)
+            worker.store.linkDeriverToPath(drvPath, outputName, newInfo.path);
 }
 
 
diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index adbf8c094..74601134e 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -136,6 +136,7 @@ struct Derivation : BasicDerivation
     std::optional<BasicDerivation> tryResolve(Store & store);
 
     Derivation() = default;
+    Derivation(const BasicDerivation & bd) : BasicDerivation(bd) { }
     Derivation(BasicDerivation && bd) : BasicDerivation(std::move(bd)) { }
 };
 

From 80e335bb5837d7bfbf1f14d4f3d39525013c4f4d Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Mon, 28 Sep 2020 15:43:56 +0000
Subject: [PATCH 10/11] Use `drvPath2` and give it a better name

---
 src/libstore/build.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/libstore/build.cc b/src/libstore/build.cc
index 0a6f2ccb5..0499273a4 100644
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -4315,19 +4315,19 @@ void DerivationGoal::registerOutputs()
        but it's fine to do in all cases. */
     bool isCaFloating = drv->type() == DerivationType::CAFloating;
 
-    auto drvPath2 = drvPath;
+    auto drvPathResolved = drvPath;
     if (!useDerivation && isCaFloating) {
         /* Once a floating CA derivations reaches this point, it
            must already be resolved, so we don't bother trying to
            downcast drv to get would would just be an empty
            inputDrvs field. */
         Derivation drv2 { *drv };
-        drvPath2 = writeDerivation(worker.store, drv2);
+        drvPathResolved = writeDerivation(worker.store, drv2);
     }
 
     if (useDerivation || isCaFloating)
         for (auto & [outputName, newInfo] : infos)
-            worker.store.linkDeriverToPath(drvPath, outputName, newInfo.path);
+            worker.store.linkDeriverToPath(drvPathResolved, outputName, newInfo.path);
 }
 
 

From 00135e13f49e9b20e3ef03f2516e7cc277c40ca9 Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Mon, 28 Sep 2020 18:19:10 +0000
Subject: [PATCH 11/11] Clarify comment a bit

---
 src/libstore/derivations.hh | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index 74601134e..d48266774 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -128,11 +128,12 @@ struct Derivation : BasicDerivation
     std::string unparse(const Store & store, bool maskOutputs,
         std::map<std::string, StringSet> * actualInputs = nullptr) const;
 
-    /* Return the underlying basic derivation but with
+    /* Return the underlying basic derivation but with these changes:
 
-       1. input drv outputs moved to input sources.
+	   1. Input drvs are emptied, but the outputs of them that were used are
+	      added directly to input sources.
 
-       2. placeholders replaced with realized input store paths. */
+       2. Input placeholders are replaced with realized input store paths. */
     std::optional<BasicDerivation> tryResolve(Store & store);
 
     Derivation() = default;