From 93227ff65c73e726c4ceef0cdd9439e7a4301417 Mon Sep 17 00:00:00 2001 From: Eelco Dolstra Date: Wed, 31 Aug 2011 21:11:50 +0000 Subject: [PATCH] =?UTF-8?q?*=20Eliminate=20all=20uses=20of=20the=20global?= =?UTF-8?q?=20variable=20=E2=80=98store=E2=80=99=20from=20libstore.=20=20?= =?UTF-8?q?=20This=20should=20also=20fix:?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit nix-instantiate: ./../boost/shared_ptr.hpp:254: T* boost::shared_ptr::operator->() const [with T = nix::StoreAPI]: Assertion `px != 0' failed. which was caused by hashDerivationModulo() calling the ‘store’ object (during store upgrades) before openStore() assigned it. --- src/libexpr/primops.cc | 8 ++--- src/libmain/shared.cc | 4 +-- src/libmain/shared.hh | 4 ++- src/libstore/build.cc | 16 ++++----- src/libstore/derivations.cc | 11 +++--- src/libstore/derivations.hh | 8 +++-- src/libstore/gc.cc | 48 +++++++++++++------------- src/libstore/local-store.cc | 2 +- src/libstore/misc.cc | 30 ++++++++-------- src/libstore/misc.hh | 6 ++-- src/libstore/store-api.hh | 6 ++-- src/nix-env/nix-env.cc | 8 ++--- src/nix-env/profiles.cc | 2 +- src/nix-instantiate/nix-instantiate.cc | 5 ++- src/nix-store/nix-store.cc | 26 +++++++------- 15 files changed, 95 insertions(+), 89 deletions(-) diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc index 9d226a327..0e81f7b72 100644 --- a/src/libexpr/primops.cc +++ b/src/libexpr/primops.cc @@ -357,7 +357,7 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v) runs. */ if (path.at(0) == '=') { path = string(path, 1); - PathSet refs; computeFSClosure(path, refs); + PathSet refs; computeFSClosure(*store, path, refs); foreach (PathSet::iterator, j, refs) { drv.inputSrcs.insert(*j); if (isDerivation(*j)) @@ -433,7 +433,7 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v) /* Use the masked derivation expression to compute the output path. */ - Hash h = hashDerivationModulo(drv); + Hash h = hashDerivationModulo(*store, drv); foreach (DerivationOutputs::iterator, i, drv.outputs) if (i->second.path == "") { @@ -444,7 +444,7 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v) } /* Write the resulting term into the Nix store directory. */ - Path drvPath = writeDerivation(drv, drvName); + Path drvPath = writeDerivation(*store, drv, drvName); printMsg(lvlChatty, format("instantiated `%1%' -> `%2%'") % drvName % drvPath); @@ -452,7 +452,7 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v) /* Optimisation, but required in read-only mode! because in that case we don't actually write store derivations, so we can't read them later. */ - drvHashes[drvPath] = hashDerivationModulo(drv); + drvHashes[drvPath] = hashDerivationModulo(*store, drv); state.mkAttrs(v, 1 + drv.outputs.size()); mkString(*state.allocAttr(v, state.sDrvPath), drvPath, singleton("=" + drvPath)); diff --git a/src/libmain/shared.cc b/src/libmain/shared.cc index 43ec4bcdd..f0035c358 100644 --- a/src/libmain/shared.cc +++ b/src/libmain/shared.cc @@ -52,11 +52,11 @@ void printGCWarning() } -void printMissing(const PathSet & paths) +void printMissing(StoreAPI & store, const PathSet & paths) { unsigned long long downloadSize, narSize; PathSet willBuild, willSubstitute, unknown; - queryMissing(paths, willBuild, willSubstitute, unknown, downloadSize, narSize); + queryMissing(store, paths, willBuild, willSubstitute, unknown, downloadSize, narSize); if (!willBuild.empty()) { printMsg(lvlInfo, format("these derivations will be built:")); diff --git a/src/libmain/shared.hh b/src/libmain/shared.hh index c99810c78..bd3d19531 100644 --- a/src/libmain/shared.hh +++ b/src/libmain/shared.hh @@ -24,11 +24,13 @@ namespace nix { MakeError(UsageError, nix::Error); +class StoreAPI; + /* Ugh. No better place to put this. */ Path makeRootName(const Path & gcRoot, int & counter); void printGCWarning(); -void printMissing(const PathSet & paths); +void printMissing(StoreAPI & store, const PathSet & paths); template N getIntArg(const string & opt, Strings::iterator & i, const Strings::iterator & end) diff --git a/src/libstore/build.cc b/src/libstore/build.cc index 26f9fcc59..d12f41d66 100644 --- a/src/libstore/build.cc +++ b/src/libstore/build.cc @@ -934,7 +934,7 @@ void DerivationGoal::haveDerivation() assert(worker.store.isValidPath(drvPath)); /* Get the derivation. */ - drv = derivationFromPath(drvPath); + drv = derivationFromPath(worker.store, drvPath); foreach (DerivationOutputs::iterator, i, drv.outputs) worker.store.addTempRoot(i->second.path); @@ -1030,10 +1030,10 @@ void DerivationGoal::inputsRealised() `*i' as input paths. Only add the closures of output paths that are specified as inputs. */ assert(worker.store.isValidPath(i->first)); - Derivation inDrv = derivationFromPath(i->first); + Derivation inDrv = derivationFromPath(worker.store, i->first); foreach (StringSet::iterator, j, i->second) if (inDrv.outputs.find(*j) != inDrv.outputs.end()) - computeFSClosure(inDrv.outputs[*j].path, inputPaths); + computeFSClosure(worker.store, inDrv.outputs[*j].path, inputPaths); else throw Error( format("derivation `%1%' requires non-existent output `%2%' from input derivation `%3%'") @@ -1042,7 +1042,7 @@ void DerivationGoal::inputsRealised() /* Second, the input sources. */ foreach (PathSet::iterator, i, drv.inputSrcs) - computeFSClosure(*i, inputPaths); + computeFSClosure(worker.store, *i, inputPaths); debug(format("added input paths %1%") % showPaths(inputPaths)); @@ -1399,7 +1399,7 @@ HookReply DerivationGoal::tryBuildHook() list it since the remote system *probably* already has it.) */ PathSet allInputs; allInputs.insert(inputPaths.begin(), inputPaths.end()); - computeFSClosure(drvPath, allInputs); + computeFSClosure(worker.store, drvPath, allInputs); string s; foreach (PathSet::iterator, i, allInputs) s += *i + " "; @@ -1545,14 +1545,14 @@ void DerivationGoal::startBuilder() like passing all build-time dependencies of some path to a derivation that builds a NixOS DVD image. */ PathSet paths, paths2; - computeFSClosure(storePath, paths); + computeFSClosure(worker.store, storePath, paths); paths2 = paths; foreach (PathSet::iterator, j, paths2) { if (isDerivation(*j)) { - Derivation drv = derivationFromPath(*j); + Derivation drv = derivationFromPath(worker.store, *j); foreach (DerivationOutputs::iterator, k, drv.outputs) - computeFSClosure(k->second.path, paths); + computeFSClosure(worker.store, k->second.path, paths); } } diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc index db9fc6b8a..5a0f4ecc6 100644 --- a/src/libstore/derivations.cc +++ b/src/libstore/derivations.cc @@ -26,7 +26,8 @@ void DerivationOutput::parseHashInfo(bool & recursive, HashType & hashType, Hash } -Path writeDerivation(const Derivation & drv, const string & name) +Path writeDerivation(StoreAPI & store, + const Derivation & drv, const string & name) { PathSet references; references.insert(drv.inputSrcs.begin(), drv.inputSrcs.end()); @@ -39,7 +40,7 @@ Path writeDerivation(const Derivation & drv, const string & name) string contents = unparseDerivation(drv); return readOnlyMode ? computeStorePathForText(suffix, contents, references) - : store->addTextToStore(suffix, contents, references); + : store.addTextToStore(suffix, contents, references); } @@ -221,7 +222,7 @@ DrvHashes drvHashes; paths have been replaced by the result of a recursive call to this function, and that for fixed-output derivations we return a hash of its output path. */ -Hash hashDerivationModulo(Derivation drv) +Hash hashDerivationModulo(StoreAPI & store, Derivation drv) { /* Return a fixed hash for fixed-output derivations. */ if (isFixedOutputDrv(drv)) { @@ -238,8 +239,8 @@ Hash hashDerivationModulo(Derivation drv) foreach (DerivationInputs::const_iterator, i, drv.inputDrvs) { Hash h = drvHashes[i->first]; if (h.type == htUnknown) { - Derivation drv2 = derivationFromPath(i->first); - h = hashDerivationModulo(drv2); + Derivation drv2 = derivationFromPath(store, i->first); + h = hashDerivationModulo(store, drv2); drvHashes[i->first] = h; } inputs2[printHash(h)] = i->second; diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh index 4860f708c..27e471d88 100644 --- a/src/libstore/derivations.hh +++ b/src/libstore/derivations.hh @@ -53,8 +53,12 @@ struct Derivation }; +class StoreAPI; + + /* Write a derivation to the Nix store, and return its path. */ -Path writeDerivation(const Derivation & drv, const string & name); +Path writeDerivation(StoreAPI & store, + const Derivation & drv, const string & name); /* Parse a derivation. */ Derivation parseDerivation(const string & s); @@ -69,7 +73,7 @@ bool isDerivation(const string & fileName); /* Return true iff this is a fixed-output derivation. */ bool isFixedOutputDrv(const Derivation & drv); -Hash hashDerivationModulo(Derivation drv); +Hash hashDerivationModulo(StoreAPI & store, Derivation drv); /* Memoisation of hashDerivationModulo(). */ typedef std::map DrvHashes; diff --git a/src/libstore/gc.cc b/src/libstore/gc.cc index b8395bfc4..e79d93723 100644 --- a/src/libstore/gc.cc +++ b/src/libstore/gc.cc @@ -90,8 +90,8 @@ void LocalStore::addIndirectRoot(const Path & path) } -Path addPermRoot(const Path & _storePath, const Path & _gcRoot, - bool indirect, bool allowOutsideRootsDir) +Path addPermRoot(StoreAPI & store, const Path & _storePath, + const Path & _gcRoot, bool indirect, bool allowOutsideRootsDir) { Path storePath(canonPath(_storePath)); Path gcRoot(canonPath(_gcRoot)); @@ -104,7 +104,7 @@ Path addPermRoot(const Path & _storePath, const Path & _gcRoot, if (indirect) { createSymlink(gcRoot, storePath, true); - store->addIndirectRoot(gcRoot); + store.addIndirectRoot(gcRoot); } else { @@ -127,7 +127,7 @@ Path addPermRoot(const Path & _storePath, const Path & _gcRoot, check if the root is in a directory in or linked from the gcroots directory. */ if (queryBoolSetting("gc-check-reachability", false)) { - Roots roots = store->findRoots(); + Roots roots = store.findRoots(); if (roots.find(gcRoot) == roots.end()) printMsg(lvlError, format( @@ -139,7 +139,7 @@ Path addPermRoot(const Path & _storePath, const Path & _gcRoot, /* Grab the global GC root, causing us to block while a GC is in progress. This prevents the set of permanent roots from increasing while a GC is in progress. */ - store->syncWithGC(); + store.syncWithGC(); return gcRoot; } @@ -275,8 +275,8 @@ static void readTempRoots(PathSet & tempRoots, FDs & fds) } -static void findRoots(const Path & path, bool recurseSymlinks, - bool deleteStale, Roots & roots) +static void findRoots(StoreAPI & store, const Path & path, + bool recurseSymlinks, bool deleteStale, Roots & roots) { try { @@ -289,7 +289,7 @@ static void findRoots(const Path & path, bool recurseSymlinks, if (S_ISDIR(st.st_mode)) { Strings names = readDirectory(path); foreach (Strings::iterator, i, names) - findRoots(path + "/" + *i, recurseSymlinks, deleteStale, roots); + findRoots(store, path + "/" + *i, recurseSymlinks, deleteStale, roots); } else if (S_ISLNK(st.st_mode)) { @@ -299,7 +299,7 @@ static void findRoots(const Path & path, bool recurseSymlinks, debug(format("found root `%1%' in `%2%'") % target % path); Path storePath = toStorePath(target); - if (store->isValidPath(storePath)) + if (store.isValidPath(storePath)) roots[path] = storePath; else printMsg(lvlInfo, format("skipping invalid root from `%1%' to `%2%'") @@ -308,7 +308,7 @@ static void findRoots(const Path & path, bool recurseSymlinks, else if (recurseSymlinks) { if (pathExists(target)) - findRoots(target, false, deleteStale, roots); + findRoots(store, target, false, deleteStale, roots); else if (deleteStale) { printMsg(lvlInfo, format("removing stale link from `%1%' to `%2%'") % path % target); /* Note that we only delete when recursing, i.e., @@ -331,22 +331,22 @@ static void findRoots(const Path & path, bool recurseSymlinks, } -static Roots findRoots(bool deleteStale) +static Roots findRoots(StoreAPI & store, bool deleteStale) { Roots roots; Path rootsDir = canonPath((format("%1%/%2%") % nixStateDir % gcRootsDir).str()); - findRoots(rootsDir, true, deleteStale, roots); + findRoots(store, rootsDir, true, deleteStale, roots); return roots; } Roots LocalStore::findRoots() { - return nix::findRoots(false); + return nix::findRoots(*this, false); } -static void addAdditionalRoots(PathSet & roots) +static void addAdditionalRoots(StoreAPI & store, PathSet & roots) { Path rootFinder = getEnv("NIX_ROOT_FINDER", nixLibexecDir + "/nix/find-runtime-roots.pl"); @@ -362,7 +362,7 @@ static void addAdditionalRoots(PathSet & roots) foreach (Strings::iterator, i, paths) { if (isInStore(*i)) { Path path = toStorePath(*i); - if (roots.find(path) == roots.end() && store->isValidPath(path)) { + if (roots.find(path) == roots.end() && store.isValidPath(path)) { debug(format("got additional root `%1%'") % path); roots.insert(path); } @@ -371,32 +371,32 @@ static void addAdditionalRoots(PathSet & roots) } -static void dfsVisit(const PathSet & paths, const Path & path, - PathSet & visited, Paths & sorted) +static void dfsVisit(StoreAPI & store, const PathSet & paths, + const Path & path, PathSet & visited, Paths & sorted) { if (visited.find(path) != visited.end()) return; visited.insert(path); PathSet references; - if (store->isValidPath(path)) - store->queryReferences(path, references); + if (store.isValidPath(path)) + store.queryReferences(path, references); foreach (PathSet::iterator, i, references) /* Don't traverse into paths that don't exist. That can happen due to substitutes for non-existent paths. */ if (*i != path && paths.find(*i) != paths.end()) - dfsVisit(paths, *i, visited, sorted); + dfsVisit(store, paths, *i, visited, sorted); sorted.push_front(path); } -Paths topoSortPaths(const PathSet & paths) +Paths topoSortPaths(StoreAPI & store, const PathSet & paths) { Paths sorted; PathSet visited; foreach (PathSet::const_iterator, i, paths) - dfsVisit(paths, *i, visited, sorted); + dfsVisit(store, paths, *i, visited, sorted); return sorted; } @@ -582,7 +582,7 @@ void LocalStore::collectGarbage(const GCOptions & options, GCResults & results) /* Find the roots. Since we've grabbed the GC lock, the set of permanent roots cannot increase now. */ printMsg(lvlError, format("finding garbage collector roots...")); - Roots rootMap = options.ignoreLiveness ? Roots() : nix::findRoots(true); + Roots rootMap = options.ignoreLiveness ? Roots() : nix::findRoots(*this, true); foreach (Roots::iterator, i, rootMap) state.roots.insert(i->second); @@ -591,7 +591,7 @@ void LocalStore::collectGarbage(const GCOptions & options, GCResults & results) to add running programs to the set of roots (to prevent them from being garbage collected). */ if (!options.ignoreLiveness) - addAdditionalRoots(state.roots); + addAdditionalRoots(*this, state.roots); /* Read the temporary roots. This acquires read locks on all per-process temporary root files. So after this point no paths diff --git a/src/libstore/local-store.cc b/src/libstore/local-store.cc index 691069e2b..6ad4c84c6 100644 --- a/src/libstore/local-store.cc +++ b/src/libstore/local-store.cc @@ -497,7 +497,7 @@ void LocalStore::checkDerivationOutputs(const Path & drvPath, const Derivation & drvCopy.env[i->first] = ""; } - Hash h = hashDerivationModulo(drvCopy); + Hash h = hashDerivationModulo(*this, drvCopy); foreach (DerivationOutputs::const_iterator, i, drv.outputs) { Path outPath = makeOutputPath(i->first, h, drvName); diff --git a/src/libstore/misc.cc b/src/libstore/misc.cc index 01d6a97ae..d4bbccd11 100644 --- a/src/libstore/misc.cc +++ b/src/libstore/misc.cc @@ -6,15 +6,15 @@ namespace nix { -Derivation derivationFromPath(const Path & drvPath) +Derivation derivationFromPath(StoreAPI & store, const Path & drvPath) { assertStorePath(drvPath); - store->ensurePath(drvPath); + store.ensurePath(drvPath); return parseDerivation(readFile(drvPath)); } -void computeFSClosure(const Path & storePath, +void computeFSClosure(StoreAPI & store, const Path & storePath, PathSet & paths, bool flipDirection, bool includeOutputs) { if (paths.find(storePath) != paths.end()) return; @@ -22,19 +22,19 @@ void computeFSClosure(const Path & storePath, PathSet references; if (flipDirection) - store->queryReferrers(storePath, references); + store.queryReferrers(storePath, references); else - store->queryReferences(storePath, references); + store.queryReferences(storePath, references); if (includeOutputs && isDerivation(storePath)) { - PathSet outputs = store->queryDerivationOutputs(storePath); + PathSet outputs = store.queryDerivationOutputs(storePath); foreach (PathSet::iterator, i, outputs) - if (store->isValidPath(*i)) - computeFSClosure(*i, paths, flipDirection, true); + if (store.isValidPath(*i)) + computeFSClosure(store, *i, paths, flipDirection, true); } foreach (PathSet::iterator, i, references) - computeFSClosure(*i, paths, flipDirection, includeOutputs); + computeFSClosure(store, *i, paths, flipDirection, includeOutputs); } @@ -46,7 +46,7 @@ Path findOutput(const Derivation & drv, string id) } -void queryMissing(const PathSet & targets, +void queryMissing(StoreAPI & store, const PathSet & targets, PathSet & willBuild, PathSet & willSubstitute, PathSet & unknown, unsigned long long & downloadSize, unsigned long long & narSize) { @@ -61,15 +61,15 @@ void queryMissing(const PathSet & targets, done.insert(p); if (isDerivation(p)) { - if (!store->isValidPath(p)) { + if (!store.isValidPath(p)) { unknown.insert(p); continue; } - Derivation drv = derivationFromPath(p); + Derivation drv = derivationFromPath(store, p); bool mustBuild = false; foreach (DerivationOutputs::iterator, i, drv.outputs) - if (!store->isValidPath(i->second.path) && !store->hasSubstitutes(i->second.path)) + if (!store.isValidPath(i->second.path) && !store.hasSubstitutes(i->second.path)) mustBuild = true; if (mustBuild) { @@ -83,9 +83,9 @@ void queryMissing(const PathSet & targets, } else { - if (store->isValidPath(p)) continue; + if (store.isValidPath(p)) continue; SubstitutablePathInfo info; - if (store->querySubstitutablePathInfo(p, info)) { + if (store.querySubstitutablePathInfo(p, info)) { willSubstitute.insert(p); downloadSize += info.downloadSize; narSize += info.narSize; diff --git a/src/libstore/misc.hh b/src/libstore/misc.hh index abef6237e..850c12af4 100644 --- a/src/libstore/misc.hh +++ b/src/libstore/misc.hh @@ -9,7 +9,7 @@ namespace nix { /* Read a derivation, after ensuring its existence through ensurePath(). */ -Derivation derivationFromPath(const Path & drvPath); +Derivation derivationFromPath(StoreAPI & store, const Path & drvPath); /* Place in `paths' the set of all store paths in the file system closure of `storePath'; that is, all paths than can be directly or @@ -18,7 +18,7 @@ Derivation derivationFromPath(const Path & drvPath); `storePath' is returned; that is, the closures under the `referrers' relation instead of the `references' relation is returned. */ -void computeFSClosure(const Path & storePath, +void computeFSClosure(StoreAPI & store, const Path & storePath, PathSet & paths, bool flipDirection = false, bool includeOutputs = false); @@ -29,7 +29,7 @@ Path findOutput(const Derivation & drv, string id); /* Given a set of paths that are to be built, return the set of derivations that will be built, and the set of output paths that will be substituted. */ -void queryMissing(const PathSet & targets, +void queryMissing(StoreAPI & store, const PathSet & targets, PathSet & willBuild, PathSet & willSubstitute, PathSet & unknown, unsigned long long & downloadSize, unsigned long long & narSize); diff --git a/src/libstore/store-api.hh b/src/libstore/store-api.hh index 243a6324c..b3e67436c 100644 --- a/src/libstore/store-api.hh +++ b/src/libstore/store-api.hh @@ -314,13 +314,13 @@ void removeTempRoots(); /* Register a permanent GC root. */ -Path addPermRoot(const Path & storePath, const Path & gcRoot, - bool indirect, bool allowOutsideRootsDir = false); +Path addPermRoot(StoreAPI & store, const Path & storePath, + const Path & gcRoot, bool indirect, bool allowOutsideRootsDir = false); /* Sort a set of paths topologically under the references relation. If p refers to q, then p follows q in this list. */ -Paths topoSortPaths(const PathSet & paths); +Paths topoSortPaths(StoreAPI & store, const PathSet & paths); /* For now, there is a single global store API object, but we'll diff --git a/src/nix-env/nix-env.cc b/src/nix-env/nix-env.cc index 731f91bba..3dfecb2d7 100644 --- a/src/nix-env/nix-env.cc +++ b/src/nix-env/nix-env.cc @@ -381,7 +381,7 @@ static void queryInstSources(EvalState & state, if (isDerivation(path)) { elem.setDrvPath(path); - elem.setOutPath(findOutput(derivationFromPath(path), "out")); + elem.setOutPath(findOutput(derivationFromPath(*store, path), "out")); if (name.size() >= drvExtension.size() && string(name, name.size() - drvExtension.size()) == drvExtension) name = string(name, 0, name.size() - drvExtension.size()); @@ -430,7 +430,7 @@ static void printMissing(EvalState & state, const DrvInfos & elems) targets.insert(i->queryOutPath(state)); } - printMissing(targets); + printMissing(*store, targets); } @@ -693,12 +693,12 @@ static void opSet(Globals & globals, if (drv.queryDrvPath(globals.state) != "") { PathSet paths = singleton(drv.queryDrvPath(globals.state)); - printMissing(paths); + printMissing(*store, paths); if (globals.dryRun) return; store->buildDerivations(paths); } else { - printMissing(singleton(drv.queryOutPath(globals.state))); + printMissing(*store, singleton(drv.queryOutPath(globals.state))); if (globals.dryRun) return; store->ensurePath(drv.queryOutPath(globals.state)); } diff --git a/src/nix-env/profiles.cc b/src/nix-env/profiles.cc index 60576f1ae..5cc0d9a1c 100644 --- a/src/nix-env/profiles.cc +++ b/src/nix-env/profiles.cc @@ -91,7 +91,7 @@ Path createGeneration(Path profile, Path outPath) user environment etc. we've just built. */ Path generation; makeName(profile, num + 1, generation); - addPermRoot(outPath, generation, false, true); + addPermRoot(*store, outPath, generation, false, true); return generation; } diff --git a/src/nix-instantiate/nix-instantiate.cc b/src/nix-instantiate/nix-instantiate.cc index 05b9d5479..98eadbd69 100644 --- a/src/nix-instantiate/nix-instantiate.cc +++ b/src/nix-instantiate/nix-instantiate.cc @@ -64,9 +64,8 @@ void processExpr(EvalState & state, const Strings & attrPaths, if (gcRoot == "") printGCWarning(); else - drvPath = addPermRoot(drvPath, - makeRootName(gcRoot, rootNr), - indirectRoot); + drvPath = addPermRoot(*store, drvPath, + makeRootName(gcRoot, rootNr), indirectRoot); std::cout << format("%1%\n") % drvPath; } } diff --git a/src/nix-store/nix-store.cc b/src/nix-store/nix-store.cc index 49a705585..00dab5f32 100644 --- a/src/nix-store/nix-store.cc +++ b/src/nix-store/nix-store.cc @@ -58,14 +58,13 @@ static Path realisePath(const Path & path) PathSet paths; paths.insert(path); store->buildDerivations(paths); - Path outPath = findOutput(derivationFromPath(path), "out"); + Path outPath = findOutput(derivationFromPath(*store, path), "out"); if (gcRoot == "") printGCWarning(); else - outPath = addPermRoot(outPath, - makeRootName(gcRoot, rootNr), - indirectRoot); + outPath = addPermRoot(*store, outPath, + makeRootName(gcRoot, rootNr), indirectRoot); return outPath; } else { @@ -87,7 +86,7 @@ static void opRealise(Strings opFlags, Strings opArgs) foreach (Strings::iterator, i, opArgs) *i = followLinksToStorePath(*i); - printMissing(PathSet(opArgs.begin(), opArgs.end())); + printMissing(*store, PathSet(opArgs.begin(), opArgs.end())); if (dryRun) return; @@ -170,7 +169,7 @@ static Path maybeUseOutput(const Path & storePath, bool useOutput, bool forceRea { if (forceRealise) realisePath(storePath); if (useOutput && isDerivation(storePath)) { - Derivation drv = derivationFromPath(storePath); + Derivation drv = derivationFromPath(*store, storePath); return findOutput(drv, "out"); } else return storePath; @@ -210,7 +209,7 @@ static void printTree(const Path & path, closure(B). That is, if derivation A is an (possibly indirect) input of B, then A is printed first. This has the effect of flattening the tree, preventing deeply nested structures. */ - Paths sorted = topoSortPaths(references); + Paths sorted = topoSortPaths(*store, references); reverse(sorted.begin(), sorted.end()); for (Paths::iterator i = sorted.begin(); i != sorted.end(); ++i) { @@ -265,7 +264,7 @@ static void opQuery(Strings opFlags, Strings opArgs) foreach (Strings::iterator, i, opArgs) { *i = followLinksToStorePath(*i); if (forceRealise) realisePath(*i); - Derivation drv = derivationFromPath(*i); + Derivation drv = derivationFromPath(*store, *i); cout << format("%1%\n") % findOutput(drv, "out"); } break; @@ -278,12 +277,12 @@ static void opQuery(Strings opFlags, Strings opArgs) PathSet paths; foreach (Strings::iterator, i, opArgs) { Path path = maybeUseOutput(followLinksToStorePath(*i), useOutput, forceRealise); - if (query == qRequisites) computeFSClosure(path, paths, false, includeOutputs); + if (query == qRequisites) computeFSClosure(*store, path, paths, false, includeOutputs); else if (query == qReferences) store->queryReferences(path, paths); else if (query == qReferrers) store->queryReferrers(path, paths); - else if (query == qReferrersClosure) computeFSClosure(path, paths, true); + else if (query == qReferrersClosure) computeFSClosure(*store, path, paths, true); } - Paths sorted = topoSortPaths(paths); + Paths sorted = topoSortPaths(*store, paths); for (Paths::reverse_iterator i = sorted.rbegin(); i != sorted.rend(); ++i) cout << format("%s\n") % *i; @@ -301,7 +300,7 @@ static void opQuery(Strings opFlags, Strings opArgs) case qBinding: foreach (Strings::iterator, i, opArgs) { Path path = useDeriver(followLinksToStorePath(*i)); - Derivation drv = derivationFromPath(path); + Derivation drv = derivationFromPath(*store, path); StringPairs::iterator j = drv.env.find(bindingName); if (j == drv.env.end()) throw Error(format("derivation `%1%' has no environment binding named `%2%'") @@ -355,7 +354,8 @@ static void opQuery(Strings opFlags, Strings opArgs) case qRoots: { PathSet referrers; foreach (Strings::iterator, i, opArgs) - computeFSClosure(maybeUseOutput(followLinksToStorePath(*i), useOutput, forceRealise), + computeFSClosure(*store, + maybeUseOutput(followLinksToStorePath(*i), useOutput, forceRealise), referrers, true); Roots roots = store->findRoots(); foreach (Roots::iterator, i, roots)