forked from lix-project/lix
91dc023665
Whenever Nix attempts to realise a derivation for which a closure is already known, but this closure cannot be realised, fall back on normalising the derivation. The most common scenario in which this is useful is when we have registered substitutes in order to perform binary distribution from, say, a network repository. If the repository is down, the realisation of the derivation will fail. When this option is specified, Nix will build the derivation instead. Thus, binary installation falls back on a source installation. This option is not the default since it is generally not desirable for a transient failure in obtaining the substitutes to lead to a full build from source (with the related consumption of resources).
49 lines
1.8 KiB
C++
49 lines
1.8 KiB
C++
#ifndef __NORMALISE_H
|
|
#define __NORMALISE_H
|
|
|
|
#include "storeexpr.hh"
|
|
|
|
|
|
/* Normalise a store expression. That is, if the expression is a
|
|
derivation, a path containing an equivalent closure expression is
|
|
returned. This requires that the derivation is performed, unless a
|
|
successor is known. */
|
|
Path normaliseStoreExpr(const Path & nePath);
|
|
|
|
/* Realise a store expression. If the expression is a derivation, it
|
|
is first normalised into a closure. The closure is then realised
|
|
in the file system (i.e., it is ensured that each path in the
|
|
closure exists in the file system, if necessary by using the
|
|
substitute mechanism). Returns the normal form of the expression
|
|
(i.e., its closure expression). */
|
|
Path realiseStoreExpr(const Path & nePath);
|
|
|
|
/* Ensure that a path exists, possibly by instantiating it by
|
|
realising a substitute. */
|
|
void ensurePath(const Path & path);
|
|
|
|
/* Read a store expression, after ensuring its existence through
|
|
ensurePath(). */
|
|
StoreExpr storeExprFromPath(const Path & path);
|
|
|
|
/* Get the list of root (output) paths of the given store
|
|
expression. */
|
|
PathSet storeExprRoots(const Path & nePath);
|
|
|
|
/* Get the list of paths that are required to realise the given store
|
|
expression. For a derive expression, this is the union of
|
|
requisites of the inputs; for a closure expression, it is the path
|
|
of each element in the closure. If `includeExprs' is true, include
|
|
the paths of the store expressions themselves. If
|
|
`includeSuccessors' is true, include the requisites of
|
|
successors. */
|
|
PathSet storeExprRequisites(const Path & nePath,
|
|
bool includeExprs, bool includeSuccessors);
|
|
|
|
/* Return the list of the paths of all known store expressions whose
|
|
output paths are completely contained in the set `outputs'. */
|
|
PathSet findGenerators(const PathSet & outputs);
|
|
|
|
|
|
#endif /* !__NORMALISE_H */
|