Make imports from unrealised derivations work well with queries

src/libexpr/get-drvs.cc

@@ -1,6 +1,7 @@
 #include "get-drvs.hh"
 #include "util.hh"
 #include "eval-inline.hh"
+#include "globals.hh"
 
 
 namespace nix {
@@ -11,7 +12,13 @@ string DrvInfo::queryDrvPath(EvalState & state) const
     if (drvPath == "" && attrs) {
         Bindings::iterator i = attrs->find(state.sDrvPath);
         PathSet context;
-        (string &) drvPath = i != attrs->end() ? state.coerceToPath(*i->value, context) : "";
+        try {
+            (string &) drvPath = i != attrs->end() ? state.coerceToPath(*i->value, context) : "";
+        } catch (ImportReadOnlyError & e) {
+            if (!recoverFromReadOnlyErrors) throw;
+            ((ErrorAttrs &) error).insert("drvPath");
+            (string &) drvPath = "<derivation path unknown>";
+        }
     }
     return drvPath;
 }
@@ -22,7 +29,13 @@ string DrvInfo::queryOutPath(EvalState & state) const
     if (outPath == "" && attrs) {
         Bindings::iterator i = attrs->find(state.sOutPath);
         PathSet context;
-        (string &) outPath = i != attrs->end() ? state.coerceToPath(*i->value, context) : "";
+        try {
+            (string &) outPath = i != attrs->end() ? state.coerceToPath(*i->value, context) : "";
+        } catch (ImportReadOnlyError & e) {
+            if (!recoverFromReadOnlyErrors) throw;
+            ((ErrorAttrs &) error).insert("drvPath");
+            (string &) outPath = "<output path unknown>";
+        }
     }
     return outPath;
 }
@@ -37,11 +50,23 @@ MetaInfo DrvInfo::queryMetaInfo(EvalState & state) const
     Bindings::iterator a = attrs->find(state.sMeta);
     if (a == attrs->end()) return meta; /* fine, empty meta information */
 
-    state.forceAttrs(*a->value);
+    try {
+        state.forceAttrs(*a->value);
+    } catch (ImportReadOnlyError & e) {
+        if (!recoverFromReadOnlyErrors) throw;
+        ((ErrorAttrs &) error).insert("meta");
+        return meta;
+    }
 
     foreach (Bindings::iterator, i, *a->value->attrs) {
         MetaValue value;
-        state.forceValue(*i->value);
+        try {
+            state.forceAttrs(*a->value);
+        } catch (ImportReadOnlyError & e) {
+            if (!recoverFromReadOnlyErrors) throw;
+            ((ErrorAttrs &) metaError).insert(i->name);
+            continue;
+        }
         if (i->value->type == tString) {
             value.type = MetaValue::tpString;
             value.stringValue = i->value->string.s;
@@ -69,6 +94,8 @@ MetaValue DrvInfo::queryMetaInfo(EvalState & state, const string & name) const
 
 void DrvInfo::setMetaInfo(const MetaInfo & meta)
 {
+    error.erase("meta");
+    metaError.clear();
     metaInfoRead = true;
     this->meta = meta;
 }
@@ -96,17 +123,27 @@ static bool getDerivation(EvalState & state, Value & v,
         done.insert(v.attrs);
 
         DrvInfo drv;
-    
+
         Bindings::iterator i = v.attrs->find(state.sName);
         /* !!! We really would like to have a decent back trace here. */
         if (i == v.attrs->end()) throw TypeError("derivation name missing");
-        drv.name = state.forceStringNoCtx(*i->value);
+        try {
+            drv.name = state.forceStringNoCtx(*i->value);
+        } catch (ImportReadOnlyError & e) {
+            if (!recoverFromReadOnlyErrors) throw;
+            drv.error.insert("name");
+        }
 
         Bindings::iterator i2 = v.attrs->find(state.sSystem);
         if (i2 == v.attrs->end())
             drv.system = "unknown";
         else
-            drv.system = state.forceStringNoCtx(*i2->value);
+            try {
+                drv.system = state.forceStringNoCtx(*i2->value);
+            } catch (ImportReadOnlyError & e) {
+                if (!recoverFromReadOnlyErrors) throw;
+                drv.error.insert("system");
+            }
 
         drv.attrs = v.attrs;
 
@@ -117,6 +154,9 @@ static bool getDerivation(EvalState & state, Value & v,
 
     } catch (AssertionError & e) {
         return false;
+    } catch (ImportReadOnlyError & e) {
+        if (!recoverFromReadOnlyErrors) throw;
+        return false;
     }
 }
 
@@ -179,6 +219,10 @@ static void getDerivations(EvalState & state, Value & vIn,
                    attribute. */
                 if (v2.type == tAttrs) {
                     Bindings::iterator j = v2.attrs->find(state.symbols.create("recurseForDerivations"));
+                    /* !!! in the weird case where v2.recurseForDerivations
+                       requires evaluating an import of an unrealised derivation
+                       to be evaluated, this will throw in read-only
+                       mode even if read-only recovery was specified */
                     if (j != v2.attrs->end() && state.forceBool(*j->value))
                         getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done);
                 }

src/libexpr/get-drvs.hh

@@ -23,6 +23,7 @@ struct MetaValue
 
 typedef std::map<string, MetaValue> MetaInfo;
 
+typedef std::set<string> ErrorAttrs;
 
 struct DrvInfo
 {
@@ -37,6 +38,8 @@ public:
     string name;
     string attrPath; /* path towards the derivation */
     string system;
+    ErrorAttrs error;
+    ErrorAttrs metaError;
 
     /* !!! make this private */
     Bindings * attrs;
@@ -50,11 +53,13 @@ public:
 
     void setDrvPath(const string & s)
     {
+        error.erase("drvPath");
         drvPath = s;
     }
 
     void setOutPath(const string & s)
     {
+        error.erase("outPath");
         outPath = s;
     }
 

src/libexpr/nixexpr.hh

@@ -17,6 +17,7 @@ MakeError(ThrownError, AssertionError)
 MakeError(Abort, EvalError)
 MakeError(TypeError, EvalError)
 MakeError(ImportError, EvalError) // error building an imported derivation
+MakeError(ImportReadOnlyError, EvalError) // error when trying to import a derivation in read-only mode
 
 
 /* Position objects. */

src/libexpr/primops.cc

@@ -45,18 +45,35 @@ static void prim_import(EvalState & state, Value * * args, Value & v)
 
     foreach (PathSet::iterator, i, context) {
         Path ctx = decodeContext(*i).first;
+        string outputName = decodeContext(*i).second;
         assert(isStorePath(ctx));
-        if (!store->isValidPath(ctx))
-            throw EvalError(format("cannot import `%1%', since path `%2%' is not valid")
-                % path % ctx);
-        if (isDerivation(ctx))
-            try {
-                /* !!! If using a substitute, we only need to fetch
-                   the selected output of this derivation. */
-                store->buildDerivations(singleton<PathSet>(ctx));
-            } catch (Error & e) {
-                throw ImportError(e.msg());
+        if (!store->isValidPath(ctx)) {
+            if (outputName.empty())
+                throw EvalError(format("cannot import `%1%', since path `%2%' is not valid")
+                    % path % ctx);
+            else
+                throw ImportReadOnlyError(format("cannot import `%1%', since path `%2%' cannot be written to the store in read-only mode")
+                    % path % ctx);
+        }
+        if (isDerivation(ctx)) {
+            Derivation drv = derivationFromPath(*store, ctx);
+
+            if (outputName.empty() ||
+                    !store->isValidPath(drv.outputs[outputName].path)) {
+                if (readOnlyMode)
+                    foreach (DerivationOutputs::iterator, j, drv.outputs)
+                        if (!store->isValidPath(j->second.path))
+                            throw ImportReadOnlyError(format("cannot import `%1%', since derivation `%2%' cannot be realised in read-only mode")
+                                % path % ctx);
+                try {
+                    /* !!! If using a substitute, we only need to fetch
+                       the selected output of this derivation. */
+                    store->buildDerivations(singleton<PathSet>(ctx));
+                } catch (Error & e) {
+                    throw ImportError(e.msg());
+                }
             }
+        }
     }
 
     state.evalFile(path, v);

src/libstore/globals.cc

@@ -26,6 +26,7 @@ Verbosity buildVerbosity = lvlError;
 unsigned int maxBuildJobs = 1;
 unsigned int buildCores = 1;
 bool readOnlyMode = false;
+bool recoverFromReadOnlyErrors = false;
 string thisSystem = "unset";
 time_t maxSilentTime = 0;
 time_t buildTimeout = 0;

src/libstore/globals.hh

@@ -64,6 +64,10 @@ extern unsigned int buildCores;
    database. */
 extern bool readOnlyMode;
 
+/* Whether failures due to read-only mode should cause a crash or allow
+   the tool to try to work around them. */
+extern bool recoverFromReadOnlyErrors;
+
 /* The canonical system name, as returned by config.guess. */ 
 extern string thisSystem;