aboutsummaryrefslogtreecommitdiff
path: root/src/libexpr
diff options
context:
space:
mode:
Diffstat (limited to 'src/libexpr')
-rw-r--r--src/libexpr/attr-path.cc4
-rw-r--r--src/libexpr/attr-path.hh2
-rw-r--r--src/libexpr/attr-set.cc6
-rw-r--r--src/libexpr/attr-set.hh9
-rw-r--r--src/libexpr/common-eval-args.cc24
-rw-r--r--src/libexpr/common-eval-args.hh2
-rw-r--r--src/libexpr/eval.cc15
-rw-r--r--src/libexpr/eval.hh28
-rw-r--r--src/libexpr/parser.y4
-rw-r--r--src/libexpr/primops.cc22
-rw-r--r--src/libexpr/primops/fetchGit.cc186
-rw-r--r--src/libexpr/primops/fetchGit.hh23
-rw-r--r--src/libexpr/primops/fetchMercurial.cc8
-rw-r--r--src/libexpr/primops/flake.cc647
-rw-r--r--src/libexpr/primops/flake.hh147
-rw-r--r--src/libexpr/primops/flakeref.cc251
-rw-r--r--src/libexpr/primops/flakeref.hh188
17 files changed, 1466 insertions, 100 deletions
diff --git a/src/libexpr/attr-path.cc b/src/libexpr/attr-path.cc
index b0f80db32..832235cfd 100644
--- a/src/libexpr/attr-path.cc
+++ b/src/libexpr/attr-path.cc
@@ -70,7 +70,7 @@ Value * findAlongAttrPath(EvalState & state, const string & attrPath,
Bindings::iterator a = v->attrs->find(state.symbols.create(attr));
if (a == v->attrs->end())
- throw Error(format("attribute '%1%' in selection path '%2%' not found") % attr % attrPath);
+ throw AttrPathNotFound("attribute '%1%' in selection path '%2%' not found", attr, attrPath);
v = &*a->value;
}
@@ -82,7 +82,7 @@ Value * findAlongAttrPath(EvalState & state, const string & attrPath,
% attrPath % showType(*v));
if (attrIndex >= v->listSize())
- throw Error(format("list index %1% in selection path '%2%' is out of range") % attrIndex % attrPath);
+ throw AttrPathNotFound("list index %1% in selection path '%2%' is out of range", attrIndex, attrPath);
v = v->listElems()[attrIndex];
}
diff --git a/src/libexpr/attr-path.hh b/src/libexpr/attr-path.hh
index 46a341950..1eae64625 100644
--- a/src/libexpr/attr-path.hh
+++ b/src/libexpr/attr-path.hh
@@ -7,6 +7,8 @@
namespace nix {
+MakeError(AttrPathNotFound, Error);
+
Value * findAlongAttrPath(EvalState & state, const string & attrPath,
Bindings & autoArgs, Value & vIn);
diff --git a/src/libexpr/attr-set.cc b/src/libexpr/attr-set.cc
index 0785897d2..b1d61a285 100644
--- a/src/libexpr/attr-set.cc
+++ b/src/libexpr/attr-set.cc
@@ -43,6 +43,12 @@ Value * EvalState::allocAttr(Value & vAttrs, const Symbol & name)
}
+Value * EvalState::allocAttr(Value & vAttrs, const std::string & name)
+{
+ return allocAttr(vAttrs, symbols.create(name));
+}
+
+
void Bindings::sort()
{
std::sort(begin(), end());
diff --git a/src/libexpr/attr-set.hh b/src/libexpr/attr-set.hh
index 3119a1848..6c5fb21ad 100644
--- a/src/libexpr/attr-set.hh
+++ b/src/libexpr/attr-set.hh
@@ -4,6 +4,7 @@
#include "symbol-table.hh"
#include <algorithm>
+#include <optional>
namespace nix {
@@ -63,6 +64,14 @@ public:
return end();
}
+ std::optional<Attr *> get(const Symbol & name)
+ {
+ Attr key(name, 0);
+ iterator i = std::lower_bound(begin(), end(), key);
+ if (i != end() && i->name == name) return &*i;
+ return {};
+ }
+
iterator begin() { return &attrs[0]; }
iterator end() { return &attrs[size_]; }
diff --git a/src/libexpr/common-eval-args.cc b/src/libexpr/common-eval-args.cc
index 3e0c78f28..7c0d268bd 100644
--- a/src/libexpr/common-eval-args.cc
+++ b/src/libexpr/common-eval-args.cc
@@ -26,6 +26,22 @@ MixEvalArgs::MixEvalArgs()
.description("add a path to the list of locations used to look up <...> file names")
.label("path")
.handler([&](std::string s) { searchPath.push_back(s); });
+
+ mkFlag()
+ .longName("impure")
+ .description("allow access to mutable paths and repositories")
+ .handler([&](std::vector<std::string> ss) {
+ evalSettings.pureEval = false;
+ });
+
+ mkFlag()
+ .longName("override-flake")
+ .labels({"original-ref", "resolved-ref"})
+ .description("override a flake registry value")
+ .arity(2)
+ .handler([&](std::vector<std::string> ss) {
+ registryOverrides.push_back(std::make_pair(ss[0], ss[1]));
+ });
}
Bindings * MixEvalArgs::getAutoArgs(EvalState & state)
@@ -45,9 +61,11 @@ Bindings * MixEvalArgs::getAutoArgs(EvalState & state)
Path lookupFileArg(EvalState & state, string s)
{
- if (isUri(s))
- return getDownloader()->downloadCached(state.store, s, true);
- else if (s.size() > 2 && s.at(0) == '<' && s.at(s.size() - 1) == '>') {
+ if (isUri(s)) {
+ CachedDownloadRequest request(s);
+ request.unpack = true;
+ return getDownloader()->downloadCached(state.store, request).path;
+ } else if (s.size() > 2 && s.at(0) == '<' && s.at(s.size() - 1) == '>') {
Path p = s.substr(1, s.size() - 2);
return state.findFile(p);
} else
diff --git a/src/libexpr/common-eval-args.hh b/src/libexpr/common-eval-args.hh
index be7fda783..54fb731de 100644
--- a/src/libexpr/common-eval-args.hh
+++ b/src/libexpr/common-eval-args.hh
@@ -16,6 +16,8 @@ struct MixEvalArgs : virtual Args
Strings searchPath;
+ std::vector<std::pair<std::string, std::string>> registryOverrides;
+
private:
std::map<std::string, std::string> autoArgs;
diff --git a/src/libexpr/eval.cc b/src/libexpr/eval.cc
index d8e10d9f2..0f8a105b1 100644
--- a/src/libexpr/eval.cc
+++ b/src/libexpr/eval.cc
@@ -7,6 +7,7 @@
#include "eval-inline.hh"
#include "download.hh"
#include "json.hh"
+#include "primops/flake.hh"
#include <algorithm>
#include <cstring>
@@ -302,6 +303,7 @@ EvalState::EvalState(const Strings & _searchPath, ref<Store> store)
, sOutputHash(symbols.create("outputHash"))
, sOutputHashAlgo(symbols.create("outputHashAlgo"))
, sOutputHashMode(symbols.create("outputHashMode"))
+ , sDescription(symbols.create("description"))
, repair(NoRepair)
, store(store)
, baseEnv(allocEnv(128))
@@ -451,14 +453,21 @@ Value * EvalState::addConstant(const string & name, Value & v)
Value * EvalState::addPrimOp(const string & name,
size_t arity, PrimOpFun primOp)
{
+ auto name2 = string(name, 0, 2) == "__" ? string(name, 2) : name;
+ Symbol sym = symbols.create(name2);
+
+ /* Hack to make constants lazy: turn them into a application of
+ the primop to a dummy value. */
if (arity == 0) {
+ auto vPrimOp = allocValue();
+ vPrimOp->type = tPrimOp;
+ vPrimOp->primOp = new PrimOp(primOp, 1, sym);
Value v;
- primOp(*this, noPos, nullptr, v);
+ mkApp(v, *vPrimOp, *vPrimOp);
return addConstant(name, v);
}
+
Value * v = allocValue();
- string name2 = string(name, 0, 2) == "__" ? string(name, 2) : name;
- Symbol sym = symbols.create(name2);
v->type = tPrimOp;
v->primOp = new PrimOp(primOp, arity, sym);
staticBaseEnv.vars[symbols.create(name)] = baseEnvDispl;
diff --git a/src/libexpr/eval.hh b/src/libexpr/eval.hh
index a314e01e0..46c6ea271 100644
--- a/src/libexpr/eval.hh
+++ b/src/libexpr/eval.hh
@@ -18,6 +18,10 @@ class Store;
class EvalState;
enum RepairFlag : bool;
+namespace flake {
+struct FlakeRegistry;
+}
+
typedef void (* PrimOpFun) (EvalState & state, const Pos & pos, Value * * args, Value & v);
@@ -62,6 +66,8 @@ typedef std::list<SearchPathElem> SearchPath;
/* Initialise the Boehm GC, if applicable. */
void initGC();
+typedef std::vector<std::pair<std::string, std::string>> RegistryOverrides;
+
class EvalState
{
@@ -72,7 +78,8 @@ public:
sSystem, sOverrides, sOutputs, sOutputName, sIgnoreNulls,
sFile, sLine, sColumn, sFunctor, sToString,
sRight, sWrong, sStructuredAttrs, sBuilder, sArgs,
- sOutputHash, sOutputHashAlgo, sOutputHashMode;
+ sOutputHash, sOutputHashAlgo, sOutputHashMode,
+ sDescription;
Symbol sDerivationNix;
/* If set, force copying files to the Nix store even if they
@@ -87,6 +94,9 @@ public:
const ref<Store> store;
+ RegistryOverrides registryOverrides;
+
+
private:
SrcToStore srcToStore;
@@ -209,6 +219,8 @@ public:
path. Nothing is copied to the store. */
Path coerceToPath(const Pos & pos, Value & v, PathSet & context);
+ void addRegistryOverrides(RegistryOverrides overrides) { registryOverrides = overrides; }
+
public:
/* The base environment, containing the builtin functions and
@@ -264,6 +276,7 @@ public:
Env & allocEnv(size_t size);
Value * allocAttr(Value & vAttrs, const Symbol & name);
+ Value * allocAttr(Value & vAttrs, const std::string & name);
Bindings * allocBindings(size_t capacity);
@@ -310,6 +323,16 @@ private:
friend struct ExprOpConcatLists;
friend struct ExprSelect;
friend void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v);
+
+public:
+
+ const std::vector<std::shared_ptr<flake::FlakeRegistry>> getFlakeRegistries();
+
+ std::shared_ptr<flake::FlakeRegistry> getGlobalFlakeRegistry();
+
+private:
+ std::shared_ptr<flake::FlakeRegistry> _globalFlakeRegistry;
+ std::once_flag _globalFlakeRegistryInit;
};
@@ -349,6 +372,9 @@ struct EvalSettings : Config
Setting<Strings> allowedUris{this, {}, "allowed-uris",
"Prefixes of URIs that builtin functions such as fetchurl and fetchGit are allowed to fetch."};
+
+ Setting<std::string> flakeRegistry{this, "https://raw.githubusercontent.com/NixOS/flake-registry/master/flake-registry.json", "flake-registry",
+ "Path or URI of the global flake registry."};
};
extern EvalSettings evalSettings;
diff --git a/src/libexpr/parser.y b/src/libexpr/parser.y
index 78a503907..967c88d9b 100644
--- a/src/libexpr/parser.y
+++ b/src/libexpr/parser.y
@@ -677,7 +677,9 @@ std::pair<bool, std::string> EvalState::resolveSearchPathElem(const SearchPathEl
if (isUri(elem.second)) {
try {
- res = { true, getDownloader()->downloadCached(store, elem.second, true) };
+ CachedDownloadRequest request(elem.second);
+ request.unpack = true;
+ res = { true, getDownloader()->downloadCached(store, request).path };
} catch (DownloadError & e) {
printError(format("warning: Nix search path entry '%1%' cannot be downloaded, ignoring") % elem.second);
res = { false, "" };
diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
index 06f577f36..070e72f3a 100644
--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -2050,9 +2050,9 @@ static void prim_splitVersion(EvalState & state, const Pos & pos, Value * * args
void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
const string & who, bool unpack, const std::string & defaultName)
{
- string url;
- Hash expectedHash;
- string name = defaultName;
+ CachedDownloadRequest request("");
+ request.unpack = unpack;
+ request.name = defaultName;
state.forceValue(*args[0]);
@@ -2063,27 +2063,27 @@ void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
for (auto & attr : *args[0]->attrs) {
string n(attr.name);
if (n == "url")
- url = state.forceStringNoCtx(*attr.value, *attr.pos);
+ request.uri = state.forceStringNoCtx(*attr.value, *attr.pos);
else if (n == "sha256")
- expectedHash = Hash(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA256);
+ request.expectedHash = Hash(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA256);
else if (n == "name")
- name = state.forceStringNoCtx(*attr.value, *attr.pos);
+ request.name = state.forceStringNoCtx(*attr.value, *attr.pos);
else
throw EvalError(format("unsupported argument '%1%' to '%2%', at %3%") % attr.name % who % attr.pos);
}
- if (url.empty())
+ if (request.uri.empty())
throw EvalError(format("'url' argument required, at %1%") % pos);
} else
- url = state.forceStringNoCtx(*args[0], pos);
+ request.uri = state.forceStringNoCtx(*args[0], pos);
- state.checkURI(url);
+ state.checkURI(request.uri);
- if (evalSettings.pureEval && !expectedHash)
+ if (evalSettings.pureEval && !request.expectedHash)
throw Error("in pure evaluation mode, '%s' requires a 'sha256' argument", who);
- Path res = getDownloader()->downloadCached(state.store, url, unpack, name, expectedHash);
+ Path res = getDownloader()->downloadCached(state.store, request).path;
if (state.allowedPaths)
state.allowedPaths->insert(res);
diff --git a/src/libexpr/primops/fetchGit.cc b/src/libexpr/primops/fetchGit.cc
index aaf02c856..10f6b6f72 100644
--- a/src/libexpr/primops/fetchGit.cc
+++ b/src/libexpr/primops/fetchGit.cc
@@ -1,3 +1,4 @@
+#include "fetchGit.hh"
#include "primops.hh"
#include "eval-inline.hh"
#include "download.hh"
@@ -15,24 +16,21 @@ using namespace std::string_literals;
namespace nix {
-struct GitInfo
-{
- Path storePath;
- std::string rev;
- std::string shortRev;
- uint64_t revCount = 0;
-};
-
-std::regex revRegex("^[0-9a-fA-F]{40}$");
+extern std::regex revRegex;
-GitInfo exportGit(ref<Store> store, const std::string & uri,
- std::optional<std::string> ref, std::string rev,
+GitInfo exportGit(ref<Store> store, std::string uri,
+ std::optional<std::string> ref,
+ std::optional<Hash> rev,
const std::string & name)
{
- if (evalSettings.pureEval && rev == "")
- throw Error("in pure evaluation mode, 'fetchGit' requires a Git revision");
+ assert(!rev || rev->type == htSHA1);
- if (!ref && rev == "" && hasPrefix(uri, "/") && pathExists(uri + "/.git")) {
+ bool isLocal = hasPrefix(uri, "/") && pathExists(uri + "/.git");
+
+ // If this is a local directory (but not a file:// URI) and no ref
+ // or revision is given, then allow the use of an unclean working
+ // tree.
+ if (!ref && !rev && isLocal) {
bool clean = true;
@@ -49,8 +47,7 @@ GitInfo exportGit(ref<Store> store, const std::string & uri,
files. */
GitInfo gitInfo;
- gitInfo.rev = "0000000000000000000000000000000000000000";
- gitInfo.shortRev = std::string(gitInfo.rev, 0, 7);
+ gitInfo.ref = "HEAD";
auto files = tokenizeString<std::set<std::string>>(
runProgram("git", true, { "-C", uri, "ls-files", "-z" }), "\0"s);
@@ -71,90 +68,124 @@ GitInfo exportGit(ref<Store> store, const std::string & uri,
};
gitInfo.storePath = store->addToStore("source", uri, true, htSHA256, filter);
+ gitInfo.revCount = std::stoull(runProgram("git", true, { "-C", uri, "rev-list", "--count", "HEAD" }));
+ // FIXME: maybe we should use the timestamp of the last
+ // modified dirty file?
+ gitInfo.lastModified = std::stoull(runProgram("git", true, { "-C", uri, "show", "-s", "--format=%ct", "HEAD" }));
return gitInfo;
}
-
- // clean working tree, but no ref or rev specified. Use 'HEAD'.
- rev = chomp(runProgram("git", true, { "-C", uri, "rev-parse", "HEAD" }));
- ref = "HEAD"s;
}
- if (!ref) ref = "HEAD"s;
+ if (!ref) ref = isLocal ? "HEAD" : "master";
- if (rev != "" && !std::regex_match(rev, revRegex))
- throw Error("invalid Git revision '%s'", rev);
+ // Don't clone file:// URIs (but otherwise treat them the same as
+ // remote URIs, i.e. don't use the working tree or HEAD).
+ static bool forceHttp = getEnv("_NIX_FORCE_HTTP") == "1"; // for testing
+ if (!forceHttp && hasPrefix(uri, "file://")) {
+ uri = std::string(uri, 7);
+ isLocal = true;
+ }
deletePath(getCacheDir() + "/nix/git");
+ deletePath(getCacheDir() + "/nix/gitv2");
- Path cacheDir = getCacheDir() + "/nix/gitv2/" + hashString(htSHA256, uri).to_string(Base32, false);
+ Path cacheDir = getCacheDir() + "/nix/gitv3/" + hashString(htSHA256, uri).to_string(Base32, false);
+ Path repoDir;
- if (!pathExists(cacheDir)) {
- createDirs(dirOf(cacheDir));
- runProgram("git", true, { "init", "--bare", cacheDir });
- }
+ if (isLocal) {
- Path localRefFile = cacheDir + "/refs/heads/" + *ref;
+ if (!rev)
+ rev = Hash(chomp(runProgram("git", true, { "-C", uri, "rev-parse", *ref })), htSHA1);
- bool doFetch;
- time_t now = time(0);
- /* If a rev was specified, we need to fetch if it's not in the
- repo. */
- if (rev != "") {
- try {
- runProgram("git", true, { "-C", cacheDir, "cat-file", "-e", rev });
- doFetch = false;
- } catch (ExecError & e) {
- if (WIFEXITED(e.status)) {
- doFetch = true;
- } else {
- throw;
+ if (!pathExists(cacheDir))
+ createDirs(cacheDir);
+
+ repoDir = uri;
+
+ } else {
+
+ repoDir = cacheDir;
+
+ if (!pathExists(cacheDir)) {
+ createDirs(dirOf(cacheDir));
+ runProgram("git", true, { "init", "--bare", repoDir });
+ }
+
+ Path localRefFile = repoDir + "/refs/heads/" + *ref;
+
+ bool doFetch;
+ time_t now = time(0);
+
+ /* If a rev was specified, we need to fetch if it's not in the
+ repo. */
+ if (rev) {
+ try {
+ runProgram("git", true, { "-C", repoDir, "cat-file", "-e", rev->gitRev() });
+ doFetch = false;
+ } catch (ExecError & e) {
+ if (WIFEXITED(e.status)) {
+ doFetch = true;
+ } else {
+ throw;
+ }
}
+ } else {
+ /* If the local ref is older than ‘tarball-ttl’ seconds, do a
+ git fetch to update the local ref to the remote ref. */
+ struct stat st;
+ doFetch = stat(localRefFile.c_str(), &st) != 0 ||
+ st.st_mtime + settings.tarballTtl <= now;
}
- } else {
- /* If the local ref is older than ‘tarball-ttl’ seconds, do a
- git fetch to update the local ref to the remote ref. */
- struct stat st;
- doFetch = stat(localRefFile.c_str(), &st) != 0 ||
- st.st_mtime + settings.tarballTtl <= now;
- }
- if (doFetch)
- {
- Activity act(*logger, lvlTalkative, actUnknown, fmt("fetching Git repository '%s'", uri));
- // FIXME: git stderr messes up our progress indicator, so
- // we're using --quiet for now. Should process its stderr.
- runProgram("git", true, { "-C", cacheDir, "fetch", "--quiet", "--force", "--", uri, fmt("%s:%s", *ref, *ref) });
+ if (doFetch) {
+ Activity act(*logger, lvlTalkative, actUnknown, fmt("fetching Git repository '%s'", uri));
- struct timeval times[2];
- times[0].tv_sec = now;
- times[0].tv_usec = 0;
- times[1].tv_sec = now;
- times[1].tv_usec = 0;
+ // FIXME: git stderr messes up our progress indicator, so
+ // we're using --quiet for now. Should process its stderr.
+ try {
+ runProgram("git", true, { "-C", repoDir, "fetch", "--quiet", "--force", "--", uri, fmt("%s:%s", *ref, *ref) });
+ } catch (Error & e) {
+ if (!pathExists(localRefFile)) throw;
+ warn("could not update local clone of Git repository '%s'; continuing with the most recent version", uri);
+ }
+
+ struct timeval times[2];
+ times[0].tv_sec = now;
+ times[0].tv_usec = 0;
+ times[1].tv_sec = now;
+ times[1].tv_usec = 0;
+
+ utimes(localRefFile.c_str(), times);
+ }
- utimes(localRefFile.c_str(), times);
+ if (!rev)
+ rev = Hash(chomp(readFile(localRefFile)), htSHA1);
}
// FIXME: check whether rev is an ancestor of ref.
GitInfo gitInfo;
- gitInfo.rev = rev != "" ? rev : chomp(readFile(localRefFile));
- gitInfo.shortRev = std::string(gitInfo.rev, 0, 7);
+ gitInfo.ref = *ref;
+ gitInfo.rev = *rev;
printTalkative("using revision %s of repo '%s'", gitInfo.rev, uri);
- std::string storeLinkName = hashString(htSHA512, name + std::string("\0"s) + gitInfo.rev).to_string(Base32, false);
+ std::string storeLinkName = hashString(htSHA512,
+ name + std::string("\0"s) + gitInfo.rev.gitRev()).to_string(Base32, false);
Path storeLink = cacheDir + "/" + storeLinkName + ".link";
PathLocks storeLinkLock({storeLink}, fmt("waiting for lock on '%1%'...", storeLink)); // FIXME: broken
try {
auto json = nlohmann::json::parse(readFile(storeLink));
- assert(json["name"] == name && json["rev"] == gitInfo.rev);
+ assert(json["name"] == name && Hash((std::string) json["rev"], htSHA1) == gitInfo.rev);
- gitInfo.storePath = json["storePath"];
+ Path storePath = json["storePath"];
- if (store->isValidPath(gitInfo.storePath)) {
+ if (store->isValidPath(storePath)) {
+ gitInfo.storePath = storePath;
gitInfo.revCount = json["revCount"];
+ gitInfo.lastModified = json["lastModified"];
return gitInfo;
}
@@ -164,7 +195,7 @@ GitInfo exportGit(ref<Store> store, const std::string & uri,
// FIXME: should pipe this, or find some better way to extract a
// revision.
- auto tar = runProgram("git", true, { "-C", cacheDir, "archive", gitInfo.rev });
+ auto tar = runProgram("git", true, { "-C", repoDir, "archive", gitInfo.rev.gitRev() });
Path tmpDir = createTempDir();
AutoDelete delTmpDir(tmpDir, true);
@@ -173,14 +204,16 @@ GitInfo exportGit(ref<Store> store, const std::string & uri,
gitInfo.storePath = store->addToStore(name, tmpDir);
- gitInfo.revCount = std::stoull(runProgram("git", true, { "-C", cacheDir, "rev-list", "--count", gitInfo.rev }));
+ gitInfo.revCount = std::stoull(runProgram("git", true, { "-C", repoDir, "rev-list", "--count", gitInfo.rev.gitRev() }));
+ gitInfo.lastModified = std::stoull(runProgram("git", true, { "-C", repoDir, "show", "-s", "--format=%ct", gitInfo.rev.gitRev() }));
nlohmann::json json;
json["storePath"] = gitInfo.storePath;
json["uri"] = uri;
json["name"] = name;
- json["rev"] = gitInfo.rev;
+ json["rev"] = gitInfo.rev.gitRev();
json["revCount"] = gitInfo.revCount;
+ json["lastModified"] = gitInfo.lastModified;
writeFile(storeLink, json.dump());
@@ -191,7 +224,7 @@ static void prim_fetchGit(EvalState & state, const Pos & pos, Value * * args, Va
{
std::string url;
std::optional<std::string> ref;
- std::string rev;
+ std::optional<Hash> rev;
std::string name = "source";
PathSet context;
@@ -208,7 +241,7 @@ static void prim_fetchGit(EvalState & state, const Pos & pos, Value * * args, Va
else if (n == "ref")
ref = state.forceStringNoCtx(*attr.value, *attr.pos);
else if (n == "rev")
- rev = state.forceStringNoCtx(*attr.value, *attr.pos);
+ rev = Hash(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA1);
else if (n == "name")
name = state.forceStringNoCtx(*attr.value, *attr.pos);
else
@@ -225,17 +258,20 @@ static void prim_fetchGit(EvalState & state, const Pos & pos, Value * * args, Va
// whitelist. Ah well.
state.checkURI(url);
+ if (evalSettings.pureEval && !rev)
+ throw Error("in pure evaluation mode, 'fetchGit' requires a Git revision");
+
auto gitInfo = exportGit(state.store, url, ref, rev, name);
state.mkAttrs(v, 8);
mkString(*state.allocAttr(v, state.sOutPath), gitInfo.storePath, PathSet({gitInfo.storePath}));
- mkString(*state.allocAttr(v, state.symbols.create("rev")), gitInfo.rev);
- mkString(*state.allocAttr(v, state.symbols.create("shortRev")), gitInfo.shortRev);
+ mkString(*state.allocAttr(v, state.symbols.create("rev")), gitInfo.rev.gitRev());
+ mkString(*state.allocAttr(v, state.symbols.create("shortRev")), gitInfo.rev.gitShortRev());
mkInt(*state.allocAttr(v, state.symbols.create("revCount")), gitInfo.revCount);
v.attrs->sort();
if (state.allowedPaths)
- state.allowedPaths->insert(gitInfo.storePath);
+ state.allowedPaths->insert(state.store->toRealPath(gitInfo.storePath));
}
static RegisterPrimOp r("fetchGit", 1, prim_fetchGit);
diff --git a/src/libexpr/primops/fetchGit.hh b/src/libexpr/primops/fetchGit.hh
new file mode 100644
index 000000000..006fa8b5f
--- /dev/null
+++ b/src/libexpr/primops/fetchGit.hh
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "store-api.hh"
+
+#include <regex>
+
+namespace nix {
+
+struct GitInfo
+{
+ Path storePath;
+ std::string ref;
+ Hash rev{htSHA1};
+ uint64_t revCount;
+ time_t lastModified;
+};
+
+GitInfo exportGit(ref<Store> store, std::string uri,
+ std::optional<std::string> ref,
+ std::optional<Hash> rev,
+ const std::string & name);
+
+}
diff --git a/src/libexpr/primops/fetchMercurial.cc b/src/libexpr/primops/fetchMercurial.cc
index 66f49f374..596047ce3 100644
--- a/src/libexpr/primops/fetchMercurial.cc
+++ b/src/libexpr/primops/fetchMercurial.cc
@@ -27,9 +27,6 @@ std::regex commitHashRegex("^[0-9a-fA-F]{40}$");
HgInfo exportMercurial(ref<Store> store, const std::string & uri,
std::string rev, const std::string & name)
{
- if (evalSettings.pureEval && rev == "")
- throw Error("in pure evaluation mode, 'fetchMercurial' requires a Mercurial revision");
-
if (rev == "" && hasPrefix(uri, "/") && pathExists(uri + "/.hg")) {
bool clean = runProgram("hg", true, { "status", "-R", uri, "--modified", "--added", "--removed" }) == "";
@@ -203,6 +200,9 @@ static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * ar
// whitelist. Ah well.
state.checkURI(url);
+ if (evalSettings.pureEval && rev == "")
+ throw Error("in pure evaluation mode, 'fetchMercurial' requires a Mercurial revision");
+
auto hgInfo = exportMercurial(state.store, url, rev, name);
state.mkAttrs(v, 8);
@@ -214,7 +214,7 @@ static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * ar
v.attrs->sort();
if (state.allowedPaths)
- state.allowedPaths->insert(hgInfo.storePath);
+ state.allowedPaths->insert(state.store->toRealPath(hgInfo.storePath));
}
static RegisterPrimOp r("fetchMercurial", 1, prim_fetchMercurial);
diff --git a/src/libexpr/primops/flake.cc b/src/libexpr/primops/flake.cc
new file mode 100644
index 000000000..235e10922
--- /dev/null
+++ b/src/libexpr/primops/flake.cc
@@ -0,0 +1,647 @@
+#include "flake.hh"
+#include "primops.hh"
+#include "eval-inline.hh"
+#include "fetchGit.hh"
+#include "download.hh"
+#include "args.hh"
+
+#include <iostream>
+#include <queue>
+#include <regex>
+#include <ctime>
+#include <iomanip>
+#include <nlohmann/json.hpp>
+
+namespace nix {
+
+using namespace flake;
+
+namespace flake {
+
+/* Read a registry. */
+std::shared_ptr<FlakeRegistry> readRegistry(const Path & path)
+{
+ auto registry = std::make_shared<FlakeRegistry>();
+
+ if (!pathExists(path))
+ return std::make_shared<FlakeRegistry>();
+
+ auto json = nlohmann::json::parse(readFile(path));
+
+ auto version = json.value("version", 0);
+ if (version != 1)
+ throw Error("flake registry '%s' has unsupported version %d", path, version);
+
+ auto flakes = json["flakes"];
+ for (auto i = flakes.begin(); i != flakes.end(); ++i)
+ registry->entries.emplace(i.key(), FlakeRef(i->value("uri", "")));
+
+ return registry;
+}
+
+/* Write a registry to a file. */
+void writeRegistry(const FlakeRegistry & registry, const Path & path)
+{
+ nlohmann::json json;
+ json["version"] = 1;
+ for (auto elem : registry.entries)
+ json["flakes"][elem.first.to_string()] = { {"uri", elem.second.to_string()} };
+ createDirs(dirOf(path));
+ writeFile(path, json.dump(4)); // The '4' is the number of spaces used in the indentation in the json file.
+}
+
+LockFile::FlakeEntry readFlakeEntry(nlohmann::json json)
+{
+ FlakeRef flakeRef(json["uri"]);
+ if (!flakeRef.isImmutable())
+ throw Error("cannot use mutable flake '%s' in pure mode", flakeRef);
+
+ LockFile::FlakeEntry entry(flakeRef, Hash((std::string) json["narHash"]));
+
+ auto nonFlakeInputs = json["nonFlakeInputs"];
+
+ for (auto i = nonFlakeInputs.begin(); i != nonFlakeInputs.end(); ++i) {
+ FlakeRef flakeRef(i->value("uri", ""));
+ if (!flakeRef.isImmutable())
+ throw Error("requested to fetch FlakeRef '%s' purely, which is mutable", flakeRef);
+ LockFile::NonFlakeEntry nonEntry(flakeRef, Hash(i->value("narHash", "")));
+ entry.nonFlakeEntries.insert_or_assign(i.key(), nonEntry);
+ }
+
+ auto inputs = json["inputs"];
+
+ for (auto i = inputs.begin(); i != inputs.end(); ++i)
+ entry.flakeEntries.insert_or_assign(i.key(), readFlakeEntry(*i));
+
+ return entry;
+}
+
+LockFile readLockFile(const Path & path)
+{
+ LockFile lockFile;
+
+ if (!pathExists(path))
+ return lockFile;
+
+ auto json = nlohmann::json::parse(readFile(path));
+
+ auto version = json.value("version", 0);
+ if (version != 1)
+ throw Error("lock file '%s' has unsupported version %d", path, version);
+
+ auto nonFlakeInputs = json["nonFlakeInputs"];
+
+ for (auto i = nonFlakeInputs.begin(); i != nonFlakeInputs.end(); ++i) {
+ FlakeRef flakeRef(i->value("uri", ""));
+ LockFile::NonFlakeEntry nonEntry(flakeRef, Hash(i->value("narHash", "")));
+ if (!flakeRef.isImmutable())
+ throw Error("found mutable FlakeRef '%s' in lockfile at path %s", flakeRef, path);
+ lockFile.nonFlakeEntries.insert_or_assign(i.key(), nonEntry);
+ }
+
+ auto inputs = json["inputs"];
+
+ for (auto i = inputs.begin(); i != inputs.end(); ++i)
+ lockFile.flakeEntries.insert_or_assign(i.key(), readFlakeEntry(*i));
+
+ return lockFile;
+}
+
+nlohmann::json flakeEntryToJson(const LockFile::FlakeEntry & entry)
+{
+ nlohmann::json json;
+ json["uri"] = entry.ref.to_string();
+ json["narHash"] = entry.narHash.to_string(SRI);
+ for (auto & x : entry.nonFlakeEntries) {
+ json["nonFlakeInputs"][x.first]["uri"] = x.second.ref.to_string();
+ json["nonFlakeInputs"][x.first]["narHash"] = x.second.narHash.to_string(SRI);
+ }
+ for (auto & x : entry.flakeEntries)
+ json["inputs"][x.first.to_string()] = flakeEntryToJson(x.second);
+ return json;
+}
+
+std::ostream & operator <<(std::ostream & stream, const LockFile & lockFile)
+{
+ nlohmann::json json;
+ json["version"] = 1;
+ json["nonFlakeInputs"] = nlohmann::json::object();
+ for (auto & x : lockFile.nonFlakeEntries) {
+ json["nonFlakeInputs"][x.first]["uri"] = x.second.ref.to_string();
+ json["nonFlakeInputs"][x.first]["narHash"] = x.second.narHash.to_string(SRI);
+ }
+ json["inputs"] = nlohmann::json::object();
+ for (auto & x : lockFile.flakeEntries)
+ json["inputs"][x.first.to_string()] = flakeEntryToJson(x.second);
+ stream << json.dump(4); // '4' = indentation in json file
+ return stream;
+}
+
+void writeLockFile(const LockFile & lockFile, const Path & path)
+{
+ createDirs(dirOf(path));
+ writeFile(path, fmt("%s\n", lockFile));
+}
+
+Path getUserRegistryPath()
+{
+ return getHome() + "/.config/nix/registry.json";
+}
+
+std::shared_ptr<FlakeRegistry> getUserRegistry()
+{
+ return readRegistry(getUserRegistryPath());
+}
+
+std::shared_ptr<FlakeRegistry> getFlagRegistry(RegistryOverrides registryOverrides)
+{
+ auto flagRegistry = std::make_shared<FlakeRegistry>();
+ for (auto const & x : registryOverrides) {
+ flagRegistry->entries.insert_or_assign(FlakeRef(x.first), FlakeRef(x.second));
+ }
+ return flagRegistry;
+}
+
+static FlakeRef lookupFlake(EvalState & state, const FlakeRef & flakeRef, const Registries & registries,
+ std::vector<FlakeRef> pastSearches = {});
+
+FlakeRef updateFlakeRef(EvalState & state, const FlakeRef & newRef, const Registries & registries, std::vector<FlakeRef> pastSearches)
+{
+ std::string errorMsg = "found cycle in flake registries: ";
+ for (FlakeRef oldRef : pastSearches) {
+ errorMsg += oldRef.to_string();
+ if (oldRef == newRef)
+ throw Error(errorMsg);
+ errorMsg += " - ";
+ }
+ pastSearches.push_back(newRef);
+ return lookupFlake(state, newRef, registries, pastSearches);
+}
+
+static FlakeRef lookupFlake(EvalState & state, const FlakeRef & flakeRef, const Registries & registries,
+ std::vector<FlakeRef> pastSearches)
+{
+ if (registries.empty() && !flakeRef.isDirect())
+ throw Error("indirect flake reference '%s' is not allowed", flakeRef);
+
+ for (std::shared_ptr<FlakeRegistry> registry : registries) {
+ auto i = registry->entries.find(flakeRef);
+ if (i != registry->entries.end()) {
+ auto newRef = i->second;
+ return updateFlakeRef(state, newRef, registries, pastSearches);
+ }
+
+ auto j = registry->entries.find(flakeRef.baseRef());
+ if (j != registry->entries.end()) {
+ auto newRef = j->second;
+ newRef.ref = flakeRef.ref;
+ newRef.rev = flakeRef.rev;
+ return updateFlakeRef(state, newRef, registries, pastSearches);
+ }
+ }
+
+ if (!flakeRef.isDirect())
+ throw Error("could not resolve flake reference '%s'", flakeRef);
+
+ return flakeRef;
+}
+
+// Lookups happen here too
+static SourceInfo fetchFlake(EvalState & state, const FlakeRef & flakeRef, bool impureIsAllowed = false)
+{
+ FlakeRef resolvedRef = lookupFlake(state, flakeRef,
+ impureIsAllowed ? state.getFlakeRegistries() : std::vector<std::shared_ptr<FlakeRegistry>>());
+
+ if (evalSettings.pureEval && !impureIsAllowed && !resolvedRef.isImmutable())
+ throw Error("requested to fetch mutable flake '%s' in pure mode", resolvedRef);
+
+ auto doGit = [&](const GitInfo & gitInfo) {
+ FlakeRef ref(resolvedRef.baseRef());
+ ref.ref = gitInfo.ref;
+ ref.rev = gitInfo.rev;
+ SourceInfo info(ref);
+ info.storePath = gitInfo.storePath;
+ info.revCount = gitInfo.revCount;
+ info.narHash = state.store->queryPathInfo(info.storePath)->narHash;
+ info.lastModified = gitInfo.lastModified;
+ return info;
+ };
+
+ // This only downloads only one revision of the repo, not the entire history.
+ if (auto refData = std::get_if<FlakeRef::IsGitHub>(&resolvedRef.data)) {
+
+ // FIXME: use regular /archive URLs instead? api.github.com
+ // might have stricter rate limits.
+
+ auto url = fmt("https://api.github.com/repos/%s/%s/tarball/%s",
+ refData->owner, refData->repo,
+ resolvedRef.rev ? resolvedRef.rev->to_string(Base16, false)
+ : resolvedRef.ref ? *resolvedRef.ref : "master");
+
+ std::string accessToken = settings.githubAccessToken.get();
+ if (accessToken != "")
+ url += "?access_token=" + accessToken;
+
+ CachedDownloadRequest request(url);
+ request.unpack = true;
+ request.name = "source";
+ request.ttl = resolvedRef.rev ? 1000000000 : settings.tarballTtl;
+ request.getLastModified = true;
+ auto result = getDownloader()->downloadCached(state.store, request);
+
+ if (!result.etag)
+ throw Error("did not receive an ETag header from '%s'", url);
+
+ if (result.etag->size() != 42 || (*result.etag)[0] != '"' || (*result.etag)[41] != '"')
+ throw Error("ETag header '%s' from '%s' is not a Git revision", *result.etag, url);
+
+ FlakeRef ref(resolvedRef.baseRef());
+ ref.rev = Hash(std::string(*result.etag, 1, result.etag->size() - 2), htSHA1);
+ SourceInfo info(ref);
+ info.storePath = result.storePath;
+ info.narHash = state.store->queryPathInfo(info.storePath)->narHash;
+ info.lastModified = result.lastModified;
+
+ return info;
+ }
+
+ // This downloads the entire git history
+ else if (auto refData = std::get_if<FlakeRef::IsGit>(&resolvedRef.data)) {
+ return doGit(exportGit(state.store, refData->uri, resolvedRef.ref, resolvedRef.rev, "source"));
+ }
+
+ else if (auto refData = std::get_if<FlakeRef::IsPath>(&resolvedRef.data)) {
+ if (!pathExists(refData->path + "/.git"))
+ throw Error("flake '%s' does not reference a Git repository", refData->path);
+ return doGit(exportGit(state.store, refData->path, {}, {}, "source"));
+ }
+
+ else abort();
+}
+
+// This will return the flake which corresponds to a given FlakeRef. The lookupFlake is done within `fetchFlake`, which is used here.
+Flake getFlake(EvalState & state, const FlakeRef & flakeRef, bool impureIsAllowed = false)
+{
+ SourceInfo sourceInfo = fetchFlake(state, flakeRef, impureIsAllowed);
+ debug("got flake source '%s' with flakeref %s", sourceInfo.storePath, sourceInfo.resolvedRef.to_string());
+
+ FlakeRef resolvedRef = sourceInfo.resolvedRef;
+
+ state.store->assertStorePath(sourceInfo.storePath);
+
+ if (state.allowedPaths)
+ state.allowedPaths->insert(state.store->toRealPath(sourceInfo.storePath));
+
+ // Guard against symlink attacks.
+ Path flakeFile = canonPath(sourceInfo.storePath + "/" + resolvedRef.subdir + "/flake.nix");
+ Path realFlakeFile = state.store->toRealPath(flakeFile);
+ if (!isInDir(realFlakeFile, state.store->toRealPath(sourceInfo.storePath)))
+ throw Error("'flake.nix' file of flake '%s' escapes from '%s'", resolvedRef, sourceInfo.storePath);
+
+ Flake flake(flakeRef, sourceInfo);
+
+ if (!pathExists(realFlakeFile))
+ throw Error("source tree referenced by '%s' does not contain a '%s/flake.nix' file", resolvedRef, resolvedRef.subdir);
+
+ Value vInfo;
+ state.evalFile(realFlakeFile, vInfo); // FIXME: symlink attack
+
+ state.forceAttrs(vInfo);
+
+ auto sEpoch = state.symbols.create("epoch");
+
+ if (auto epoch = vInfo.attrs->get(sEpoch)) {
+ flake.epoch = state.forceInt(*(**epoch).value, *(**epoch).pos);
+ if (flake.epoch > 2019)
+ throw Error("flake '%s' requires unsupported epoch %d; please upgrade Nix", flakeRef, flake.epoch);
+ } else
+ throw Error("flake '%s' lacks attribute 'epoch'", flakeRef);
+
+ if (auto name = vInfo.attrs->get(state.sName))
+ flake.id = state.forceStringNoCtx(*(**name).value, *(**name).pos);
+ else
+ throw Error("flake '%s' lacks attribute 'name'", flakeRef);
+
+ if (auto description = vInfo.attrs->get(state.sDescription))
+ flake.description = state.forceStringNoCtx(*(**description).value, *(**description).pos);
+
+ auto sInputs = state.symbols.create("inputs");
+
+ if (auto inputs = vInfo.attrs->get(sInputs)) {
+ state.forceList(*(**inputs).value, *(**inputs).pos);
+ for (unsigned int n = 0; n < (**inputs).value->listSize(); ++n)
+ flake.inputs.push_back(FlakeRef(state.forceStringNoCtx(
+ *(**inputs).value->listElems()[n], *(**inputs).pos)));
+ }
+
+ auto sNonFlakeInputs = state.symbols.create("nonFlakeInputs");
+
+ if (std::optional<Attr *> nonFlakeInputs = vInfo.attrs->get(sNonFlakeInputs)) {
+ state.forceAttrs(*(**nonFlakeInputs).value, *(**nonFlakeInputs).pos);
+ for (Attr attr : *(*(**nonFlakeInputs).value).attrs) {
+ std::string myNonFlakeUri = state.forceStringNoCtx(*attr.value, *attr.pos);
+ FlakeRef nonFlakeRef = FlakeRef(myNonFlakeUri);
+ flake.nonFlakeInputs.insert_or_assign(attr.name, nonFlakeRef);
+ }
+ }
+
+ auto sOutputs = state.symbols.create("outputs");
+
+ if (auto outputs = vInfo.attrs->get(sOutputs)) {
+ state.forceFunction(*(**outputs).value, *(**outputs).pos);
+ flake.vOutputs = (**outputs).value;
+ } else
+ throw Error("flake '%s' lacks attribute 'outputs'", flakeRef);
+
+ for (auto & attr : *vInfo.attrs) {
+ if (attr.name != sEpoch &&
+ attr.name != state.sName &&
+ attr.name != state.sDescription &&
+ attr.name != sInputs &&
+ attr.name != sNonFlakeInputs &&
+ attr.name != sOutputs)
+ throw Error("flake '%s' has an unsupported attribute '%s', at %s",
+ flakeRef, attr.name, *attr.pos);
+ }
+
+ return flake;
+}
+
+// Get the `NonFlake` corresponding to a `FlakeRef`.
+NonFlake getNonFlake(EvalState & state, const FlakeRef & flakeRef, FlakeAlias alias, bool impureIsAllowed = false)
+{
+ auto sourceInfo = fetchFlake(state, flakeRef, impureIsAllowed);
+ debug("got non-flake source '%s' with flakeref %s", sourceInfo.storePath, sourceInfo.resolvedRef.to_string());
+
+ FlakeRef resolvedRef = sourceInfo.resolvedRef;
+
+ NonFlake nonFlake(flakeRef, sourceInfo);
+
+ state.store->assertStorePath(nonFlake.sourceInfo.storePath);
+
+ if (state.allowedPaths)
+ state.allowedPaths->insert(nonFlake.sourceInfo.storePath);
+
+ nonFlake.alias = alias;
+
+ return nonFlake;
+}
+
+LockFile entryToLockFile(const LockFile::FlakeEntry & entry)
+{
+ LockFile lockFile;
+ lockFile.flakeEntries = entry.flakeEntries;
+ lockFile.nonFlakeEntries = entry.nonFlakeEntries;
+ return lockFile;
+}
+
+LockFile::FlakeEntry dependenciesToFlakeEntry(const ResolvedFlake & resolvedFlake)
+{
+ LockFile::FlakeEntry entry(
+ resolvedFlake.flake.sourceInfo.resolvedRef,
+ resolvedFlake.flake.sourceInfo.narHash);
+
+ for (auto & info : resolvedFlake.flakeDeps)
+ entry.flakeEntries.insert_or_assign(info.first.to_string(), dependenciesToFlakeEntry(info.second));
+
+ for (auto & nonFlake : resolvedFlake.nonFlakeDeps) {
+ LockFile::NonFlakeEntry nonEntry(
+ nonFlake.sourceInfo.resolvedRef,
+ nonFlake.sourceInfo.narHash);
+ entry.nonFlakeEntries.insert_or_assign(nonFlake.alias, nonEntry);
+ }
+
+ return entry;
+}
+
+bool allowedToWrite(HandleLockFile handle)
+{
+ return handle == UpdateLockFile || handle == RecreateLockFile;
+}
+
+bool recreateLockFile(HandleLockFile handle)
+{
+ return handle == RecreateLockFile || handle == UseNewLockFile;
+}
+
+bool allowedToUseRegistries(HandleLockFile handle, bool isTopRef)
+{
+ if (handle == AllPure) return false;
+ else if (handle == TopRefUsesRegistries) return isTopRef;
+ else if (handle == UpdateLockFile) return true;
+ else if (handle == UseUpdatedLockFile) return true;
+ else if (handle == RecreateLockFile) return true;
+ else if (handle == UseNewLockFile) return true;
+ else assert(false);
+}
+
+ResolvedFlake resolveFlakeFromLockFile(EvalState & state, const FlakeRef & flakeRef,
+ HandleLockFile handleLockFile, LockFile lockFile = {}, bool topRef = false)
+{
+ Flake flake = getFlake(state, flakeRef, allowedToUseRegistries(handleLockFile, topRef));
+
+ ResolvedFlake deps(flake);
+
+ for (auto & nonFlakeInfo : flake.nonFlakeInputs) {
+ FlakeRef ref = nonFlakeInfo.second;
+ auto i = lockFile.nonFlakeEntries.find(nonFlakeInfo.first);
+ if (i != lockFile.nonFlakeEntries.end()) {
+ NonFlake nonFlake = getNonFlake(state, i->second.ref, nonFlakeInfo.first);
+ if (nonFlake.sourceInfo.narHash != i->second.narHash)
+ throw Error("the content hash of flakeref '%s' doesn't match", i->second.ref.to_string());
+ deps.nonFlakeDeps.push_back(nonFlake);
+ } else {
+ if (handleLockFile == AllPure || handleLockFile == TopRefUsesRegistries)
+ throw Error("cannot update non-flake dependency '%s' in pure mode", nonFlakeInfo.first);
+ deps.nonFlakeDeps.push_back(getNonFlake(state, nonFlakeInfo.second, nonFlakeInfo.first, allowedToUseRegistries(handleLockFile, false)));
+ }
+ }
+
+ for (auto newFlakeRef : flake.inputs) {
+ auto i = lockFile.flakeEntries.find(newFlakeRef);
+ if (i != lockFile.flakeEntries.end()) { // Propagate lockFile downwards if possible
+ ResolvedFlake newResFlake = resolveFlakeFromLockFile(state, i->second.ref, handleLockFile, entryToLockFile(i->second));
+ if (newResFlake.flake.sourceInfo.narHash != i->second.narHash)
+ throw Error("the content hash of flakeref '%s' doesn't match", i->second.ref.to_string());
+ deps.flakeDeps.insert_or_assign(newFlakeRef, newResFlake);
+ } else {
+ if (handleLockFile == AllPure || handleLockFile == TopRefUsesRegistries)
+ throw Error("cannot update flake dependency '%s' in pure mode", newFlakeRef.to_string());
+ deps.flakeDeps.insert_or_assign(newFlakeRef, resolveFlakeFromLockFile(state, newFlakeRef, handleLockFile));
+ }
+ }
+
+ return deps;
+}
+
+/* Given a flake reference, recursively fetch it and its dependencies.
+ FIXME: this should return a graph of flakes.
+*/
+ResolvedFlake resolveFlake(EvalState & state, const FlakeRef & topRef, HandleLockFile handleLockFile)
+{
+ Flake flake = getFlake(state, topRef, allowedToUseRegistries(handleLockFile, true));
+ LockFile oldLockFile;
+
+ if (!recreateLockFile(handleLockFile)) {
+ // If recreateLockFile, start with an empty lockfile
+ // FIXME: symlink attack
+ oldLockFile = readLockFile(
+ state.store->toRealPath(flake.sourceInfo.storePath)
+ + "/" + flake.sourceInfo.resolvedRef.subdir + "/flake.lock");
+ }
+
+ LockFile lockFile(oldLockFile);
+
+ ResolvedFlake resFlake = resolveFlakeFromLockFile(state, topRef, handleLockFile, lockFile, true);
+ lockFile = entryToLockFile(dependenciesToFlakeEntry(resFlake));
+
+ if (!(lockFile == oldLockFile)) {
+ if (allowedToWrite(handleLockFile)) {
+ if (auto refData = std::get_if<FlakeRef::IsPath>(&topRef.data)) {
+ writeLockFile(lockFile, refData->path + (topRef.subdir == "" ? "" : "/" + topRef.subdir) + "/flake.lock");
+
+ // Hack: Make sure that flake.lock is visible to Git, so it ends up in the Nix store.
+ runProgram("git", true, { "-C", refData->path, "add",
+ (topRef.subdir == "" ? "" : topRef.subdir + "/") + "flake.lock" });
+ } else
+ warn("cannot write lockfile of remote flake '%s'", topRef);
+ } else if (handleLockFile != AllPure && handleLockFile != TopRefUsesRegistries)
+ warn("using updated lockfile without writing it to file");
+ }
+
+ return resFlake;
+}
+
+void updateLockFile(EvalState & state, const FlakeRef & flakeRef, bool recreateLockFile)
+{
+ resolveFlake(state, flakeRef, recreateLockFile ? RecreateLockFile : UpdateLockFile);
+}
+
+static void emitSourceInfoAttrs(EvalState & state, const SourceInfo & sourceInfo, Value & vAttrs)
+{
+ auto & path = sourceInfo.storePath;
+ state.store->isValidPath(path);
+ mkString(*state.allocAttr(vAttrs, state.sOutPath), path, {path});
+
+ if (sourceInfo.resolvedRef.rev) {
+ mkString(*state.allocAttr(vAttrs, state.symbols.create("rev")),
+ sourceInfo.resolvedRef.rev->gitRev());
+ mkString(*state.allocAttr(vAttrs, state.symbols.create("shortRev")),
+ sourceInfo.resolvedRef.rev->gitShortRev());
+ }
+
+ if (sourceInfo.revCount)
+ mkInt(*state.allocAttr(vAttrs, state.symbols.create("revCount")), *sourceInfo.revCount);
+
+ if (sourceInfo.lastModified)
+ mkString(*state.allocAttr(vAttrs, state.symbols.create("lastModified")),
+ fmt("%s",
+ std::put_time(std::gmtime(&*sourceInfo.lastModified), "%Y%m%d%H%M%S")));
+}
+
+void callFlake(EvalState & state, const ResolvedFlake & resFlake, Value & v)
+{
+ // Construct the resulting attrset '{description, outputs,
+ // ...}'. This attrset is passed lazily as an argument to 'outputs'.
+
+ state.mkAttrs(v, resFlake.flakeDeps.size() + resFlake.nonFlakeDeps.size() + 8);
+
+ for (auto info : resFlake.flakeDeps) {
+ const ResolvedFlake newResFlake = info.second;
+ auto vFlake = state.allocAttr(v, newResFlake.flake.id);
+ callFlake(state, newResFlake, *vFlake);
+ }
+
+ for (const NonFlake nonFlake : resFlake.nonFlakeDeps) {
+ auto vNonFlake = state.allocAttr(v, nonFlake.alias);
+ state.mkAttrs(*vNonFlake, 8);
+
+ state.store->isValidPath(nonFlake.sourceInfo.storePath);
+ mkString(*state.allocAttr(*vNonFlake, state.sOutPath),
+ nonFlake.sourceInfo.storePath, {nonFlake.sourceInfo.storePath});
+
+ emitSourceInfoAttrs(state, nonFlake.sourceInfo, *vNonFlake);
+ }
+
+ mkString(*state.allocAttr(v, state.sDescription), resFlake.flake.description);
+
+ emitSourceInfoAttrs(state, resFlake.flake.sourceInfo, v);
+
+ auto vOutputs = state.allocAttr(v, state.symbols.create("outputs"));
+ mkApp(*vOutputs, *resFlake.flake.vOutputs, v);
+
+ v.attrs->push_back(Attr(state.symbols.create("self"), &v));
+
+ v.attrs->sort();
+}
+
+// This function is exposed to be used in nix files.
+static void prim_getFlake(EvalState & state, const Pos & pos, Value * * args, Value & v)
+{
+ callFlake(state, resolveFlake(state, state.forceStringNoCtx(*args[0], pos),
+ evalSettings.pureEval ? AllPure : UseUpdatedLockFile), v);
+}
+
+static RegisterPrimOp r2("getFlake", 1, prim_getFlake);
+
+void gitCloneFlake(FlakeRef flakeRef, EvalState & state, Registries registries, const Path & destDir)
+{
+ flakeRef = lookupFlake(state, flakeRef, registries);
+
+ std::string uri;
+
+ Strings args = {"clone"};
+
+ if (auto refData = std::get_if<FlakeRef::IsGitHub>(&flakeRef.data)) {
+ uri = "git@github.com:" + refData->owner + "/" + refData->repo + ".git";
+ args.push_back(uri);
+ if (flakeRef.ref) {
+ args.push_back("--branch");
+ args.push_back(*flakeRef.ref);
+ }
+ } else if (auto refData = std::get_if<FlakeRef::IsGit>(&flakeRef.data)) {
+ args.push_back(refData->uri);
+ if (flakeRef.ref) {
+ args.push_back("--branch");
+ args.push_back(*flakeRef.ref);
+ }
+ }
+
+ if (destDir != "")
+ args.push_back(destDir);
+
+ runProgram("git", true, args);
+}
+
+}
+
+std::shared_ptr<flake::FlakeRegistry> EvalState::getGlobalFlakeRegistry()
+{
+ std::call_once(_globalFlakeRegistryInit, [&]() {
+ auto path = evalSettings.flakeRegistry;
+
+ if (!hasPrefix(path, "/")) {
+ CachedDownloadRequest request(evalSettings.flakeRegistry);
+ request.name = "flake-registry.json";
+ request.gcRoot = true;
+ path = getDownloader()->downloadCached(store, request).path;
+ }
+
+ _globalFlakeRegistry = readRegistry(path);
+ });
+
+ return _globalFlakeRegistry;
+}
+
+// This always returns a vector with flakeReg, userReg, globalReg.
+// If one of them doesn't exist, the registry is left empty but does exist.
+const Registries EvalState::getFlakeRegistries()
+{
+ Registries registries;
+ registries.push_back(getFlagRegistry(registryOverrides));
+ registries.push_back(getUserRegistry());
+ registries.push_back(getGlobalFlakeRegistry());
+ return registries;
+}
+
+}
diff --git a/src/libexpr/primops/flake.hh b/src/libexpr/primops/flake.hh
new file mode 100644
index 000000000..82b0973f6
--- /dev/null
+++ b/src/libexpr/primops/flake.hh
@@ -0,0 +1,147 @@
+#include "types.hh"
+#include "flakeref.hh"
+
+#include <variant>
+
+namespace nix {
+
+struct Value;
+class EvalState;
+
+namespace flake {
+
+static const size_t FLAG_REGISTRY = 0;
+static const size_t USER_REGISTRY = 1;
+static const size_t GLOBAL_REGISTRY = 2;
+
+struct FlakeRegistry
+{
+ std::map<FlakeRef, FlakeRef> entries;
+};
+
+struct LockFile
+{
+ struct NonFlakeEntry
+ {
+ FlakeRef ref;
+ Hash narHash;
+ NonFlakeEntry(const FlakeRef & flakeRef, const Hash & hash) : ref(flakeRef), narHash(hash) {};
+
+ bool operator ==(const NonFlakeEntry & other) const
+ {
+ return ref == other.ref && narHash == other.narHash;
+ }
+ };
+
+ struct FlakeEntry
+ {
+ FlakeRef ref;
+ Hash narHash;
+ std::map<FlakeRef, FlakeEntry> flakeEntries;
+ std::map<FlakeAlias, NonFlakeEntry> nonFlakeEntries;
+ FlakeEntry(const FlakeRef & flakeRef, const Hash & hash) : ref(flakeRef), narHash(hash) {};
+
+ bool operator ==(const FlakeEntry & other) const
+ {
+ return
+ ref == other.ref
+ && narHash == other.narHash
+ && flakeEntries == other.flakeEntries
+ && nonFlakeEntries == other.nonFlakeEntries;
+ }
+ };
+
+ std::map<FlakeRef, FlakeEntry> flakeEntries;
+ std::map<FlakeAlias, NonFlakeEntry> nonFlakeEntries;
+
+ bool operator ==(const LockFile & other) const
+ {
+ return
+ flakeEntries == other.flakeEntries
+ && nonFlakeEntries == other.nonFlakeEntries;
+ }
+};
+
+typedef std::vector<std::shared_ptr<FlakeRegistry>> Registries;
+
+Path getUserRegistryPath();
+
+enum HandleLockFile : unsigned int
+ { AllPure // Everything is handled 100% purely
+ , TopRefUsesRegistries // The top FlakeRef uses the registries, apart from that, everything happens 100% purely
+ , UpdateLockFile // Update the existing lockfile and write it to file
+ , UseUpdatedLockFile // `UpdateLockFile` without writing to file
+ , RecreateLockFile // Recreate the lockfile from scratch and write it to file
+ , UseNewLockFile // `RecreateLockFile` without writing to file
+ };
+
+std::shared_ptr<FlakeRegistry> readRegistry(const Path &);
+
+void writeRegistry(const FlakeRegistry &, const Path &);
+
+struct SourceInfo
+{
+ // Immutable flakeref that this source tree was obtained from.
+ FlakeRef resolvedRef;
+
+ Path storePath;
+
+ // Number of ancestors of the most recent commit.
+ std::optional<uint64_t> revCount;
+
+ // NAR hash of the store path.
+ Hash narHash;
+
+ // A stable timestamp of this source tree. For Git and GitHub
+ // flakes, the commit date (not author date!) of the most recent
+ // commit.
+ std::optional<time_t> lastModified;
+
+ SourceInfo(const FlakeRef & resolvRef) : resolvedRef(resolvRef) {};
+};
+
+struct Flake
+{
+ FlakeId id;
+ FlakeRef originalRef;
+ std::string description;
+ SourceInfo sourceInfo;
+ std::vector<FlakeRef> inputs;
+ std::map<FlakeAlias, FlakeRef> nonFlakeInputs;
+ Value * vOutputs; // FIXME: gc
+ unsigned int epoch;
+
+ Flake(const FlakeRef & origRef, const SourceInfo & sourceInfo)
+ : originalRef(origRef), sourceInfo(sourceInfo) {};
+};
+
+struct NonFlake
+{
+ FlakeAlias alias;
+ FlakeRef originalRef;
+ SourceInfo sourceInfo;
+ NonFlake(const FlakeRef & origRef, const SourceInfo & sourceInfo)
+ : originalRef(origRef), sourceInfo(sourceInfo) {};
+};
+
+Flake getFlake(EvalState &, const FlakeRef &, bool impureIsAllowed);
+
+struct ResolvedFlake
+{
+ Flake flake;
+ std::map<FlakeRef, ResolvedFlake> flakeDeps; // The key in this map, is the originalRef as written in flake.nix
+ std::vector<NonFlake> nonFlakeDeps;
+ ResolvedFlake(const Flake & flake) : flake(flake) {}
+};
+
+ResolvedFlake resolveFlake(EvalState &, const FlakeRef &, HandleLockFile);
+
+void callFlake(EvalState & state, const ResolvedFlake & resFlake, Value & v);
+
+void updateLockFile(EvalState &, const FlakeRef & flakeRef, bool recreateLockFile);
+
+void gitCloneFlake(FlakeRef flakeRef, EvalState &, Registries, const Path & destDir);
+
+}
+
+}
diff --git a/src/libexpr/primops/flakeref.cc b/src/libexpr/primops/flakeref.cc
new file mode 100644
index 000000000..6c90c3b64
--- /dev/null
+++ b/src/libexpr/primops/flakeref.cc
@@ -0,0 +1,251 @@
+#include "flakeref.hh"
+#include "store-api.hh"
+
+#include <regex>
+
+namespace nix {
+
+// A Git ref (i.e. branch or tag name).
+const static std::string refRegex = "[a-zA-Z0-9][a-zA-Z0-9_.-]*"; // FIXME: check
+
+// A Git revision (a SHA-1 commit hash).
+const static std::string revRegexS = "[0-9a-fA-F]{40}";
+std::regex revRegex(revRegexS, std::regex::ECMAScript);
+
+// A Git ref or revision.
+const static std::string revOrRefRegex = "(?:(" + revRegexS + ")|(" + refRegex + "))";
+
+// A rev ("e72daba8250068216d79d2aeef40d4d95aff6666"), or a ref
+// optionally followed by a rev (e.g. "master" or
+// "master/e72daba8250068216d79d2aeef40d4d95aff6666").
+const static std::string refAndOrRevRegex = "(?:(" + revRegexS + ")|(?:(" + refRegex + ")(?:/(" + revRegexS + "))?))";
+
+const static std::string flakeAlias = "[a-zA-Z][a-zA-Z0-9_-]*";
+
+// GitHub references.
+const static std::string ownerRegex = "[a-zA-Z][a-zA-Z0-9_-]*";
+const static std::string repoRegex = "[a-zA-Z][a-zA-Z0-9_-]*";
+
+// URI stuff.
+const static std::string schemeRegex = "(?:http|https|ssh|git|file)";
+const static std::string authorityRegex = "[a-zA-Z0-9._~-]*";
+const static std::string segmentRegex = "[a-zA-Z0-9._~-]+";
+const static std::string pathRegex = "/?" + segmentRegex + "(?:/" + segmentRegex + ")*";
+
+// 'dir' path elements cannot start with a '.'. We also reject
+// potentially dangerous characters like ';'.
+const static std::string subDirElemRegex = "(?:[a-zA-Z0-9_-]+[a-zA-Z0-9._-]*)";
+const static std::string subDirRegex = subDirElemRegex + "(?:/" + subDirElemRegex + ")*";
+
+
+FlakeRef::FlakeRef(const std::string & uri_, bool allowRelative)
+{
+ // FIXME: could combine this into one regex.
+
+ static std::regex flakeRegex(
+ "(?:flake:)?(" + flakeAlias + ")(?:/(?:" + refAndOrRevRegex + "))?",
+ std::regex::ECMAScript);
+
+ static std::regex githubRegex(
+ "github:(" + ownerRegex + ")/(" + repoRegex + ")(?:/" + revOrRefRegex + ")?",
+ std::regex::ECMAScript);
+
+ static std::regex uriRegex(
+ "((" + schemeRegex + "):" +
+ "(?://(" + authorityRegex + "))?" +
+ "(" + pathRegex + "))",
+ std::regex::ECMAScript);
+
+ static std::regex refRegex2(refRegex, std::regex::ECMAScript);
+
+ static std::regex subDirRegex2(subDirRegex, std::regex::ECMAScript);
+
+ auto [uri, params] = splitUriAndParams(uri_);
+
+ auto handleSubdir = [&](const std::string & name, const std::string & value) {
+ if (name == "dir") {
+ if (value != "" && !std::regex_match(value, subDirRegex2))
+ throw BadFlakeRef("flake '%s' has invalid subdirectory '%s'", uri, value);
+ subdir = value;
+ return true;
+ } else
+ return false;
+ };
+
+ auto handleGitParams = [&](const std::string & name, const std::string & value) {
+ if (name == "rev") {
+ if (!std::regex_match(value, revRegex))
+ throw BadFlakeRef("invalid Git revision '%s'", value);
+ rev = Hash(value, htSHA1);
+ } else if (name == "ref") {
+ if (!std::regex_match(value, refRegex2))
+ throw BadFlakeRef("invalid Git ref '%s'", value);
+ ref = value;
+ } else if (handleSubdir(name, value))
+ ;
+ else return false;
+ return true;
+ };
+
+ std::cmatch match;
+ if (std::regex_match(uri.c_str(), match, flakeRegex)) {
+ IsAlias d;
+ d.alias = match[1];
+ if (match[2].matched)
+ rev = Hash(match[2], htSHA1);
+ else if (match[3].matched) {
+ ref = match[3];
+ if (match[4].matched)
+ rev = Hash(match[4], htSHA1);
+ }
+ data = d;
+ }
+
+ else if (std::regex_match(uri.c_str(), match, githubRegex)) {
+ IsGitHub d;
+ d.owner = match[1];
+ d.repo = match[2];
+ if (match[3].matched)
+ rev = Hash(match[3], htSHA1);
+ else if (match[4].matched) {
+ ref = match[4];
+ }
+ for (auto & param : params) {
+ if (handleSubdir(param.first, param.second))
+ ;
+ else
+ throw BadFlakeRef("invalid Git flakeref parameter '%s', in '%s'", param.first, uri);
+ }
+ data = d;
+ }
+
+ else if (std::regex_match(uri.c_str(), match, uriRegex)
+ && (match[2] == "file" || hasSuffix(match[4], ".git")))
+ {
+ IsGit d;
+ d.uri = match[1];
+ for (auto & param : params) {
+ if (handleGitParams(param.first, param.second))
+ ;
+ else
+ // FIXME: should probably pass through unknown parameters
+ throw BadFlakeRef("invalid Git flakeref parameter '%s', in '%s'", param.first, uri);
+ }
+ if (rev && !ref)
+ throw BadFlakeRef("flake URI '%s' lacks a Git ref", uri);
+ data = d;
+ }
+
+ else if ((hasPrefix(uri, "/") || (allowRelative && (hasPrefix(uri, "./") || hasPrefix(uri, "../") || uri == ".")))
+ && uri.find(':') == std::string::npos)
+ {
+ IsPath d;
+ if (allowRelative) {
+ d.path = absPath(uri);
+ while (true) {
+ if (pathExists(d.path + "/.git")) break;
+ subdir = baseNameOf(d.path) + (subdir.empty() ? "" : "/" + subdir);
+ d.path = dirOf(d.path);
+ if (d.path == "/")
+ throw BadFlakeRef("path '%s' does not reference a Git repository", uri);
+ }
+ } else
+ d.path = canonPath(uri);
+ data = d;
+ for (auto & param : params) {
+ if (handleGitParams(param.first, param.second))
+ ;
+ else
+ throw BadFlakeRef("invalid Git flakeref parameter '%s', in '%s'", param.first, uri);
+ }
+ }
+
+ else
+ throw BadFlakeRef("'%s' is not a valid flake reference", uri);
+}
+
+std::string FlakeRef::to_string() const
+{
+ std::string string;
+ bool first = true;
+
+ auto addParam =
+ [&](const std::string & name, std::string value) {
+ string += first ? '?' : '&';
+ first = false;
+ string += name;
+ string += '=';
+ string += value; // FIXME: escaping
+ };
+
+ if (auto refData = std::get_if<FlakeRef::IsAlias>(&data)) {
+ string = refData->alias;
+ if (ref) string += '/' + *ref;
+ if (rev) string += '/' + rev->gitRev();
+ }
+
+ else if (auto refData = std::get_if<FlakeRef::IsPath>(&data)) {
+ string = refData->path;
+ if (ref) addParam("ref", *ref);
+ if (rev) addParam("rev", rev->gitRev());
+ if (subdir != "") addParam("dir", subdir);
+ }
+
+ else if (auto refData = std::get_if<FlakeRef::IsGitHub>(&data)) {
+ assert(!(ref && rev));
+ string = "github:" + refData->owner + "/" + refData->repo;
+ if (ref) { string += '/'; string += *ref; }
+ if (rev) { string += '/'; string += rev->gitRev(); }
+ if (subdir != "") addParam("dir", subdir);
+ }
+
+ else if (auto refData = std::get_if<FlakeRef::IsGit>(&data)) {
+ assert(!rev || ref);
+ string = refData->uri;
+
+ if (ref) {
+ addParam("ref", *ref);
+ if (rev)
+ addParam("rev", rev->gitRev());
+ }
+
+ if (subdir != "") addParam("dir", subdir);
+ }
+
+ else abort();
+
+ assert(FlakeRef(string) == *this);
+
+ return string;
+}
+
+std::ostream & operator << (std::ostream & str, const FlakeRef & flakeRef)
+{
+ str << flakeRef.to_string();
+ return str;
+}
+
+bool FlakeRef::isImmutable() const
+{
+ return (bool) rev;
+}
+
+FlakeRef FlakeRef::baseRef() const // Removes the ref and rev from a FlakeRef.
+{
+ FlakeRef result(*this);
+ result.ref = std::nullopt;
+ result.rev = std::nullopt;
+ return result;
+}
+
+std::optional<FlakeRef> parseFlakeRef(
+ const std::string & uri, bool allowRelative)
+{
+ try {
+ return FlakeRef(uri, allowRelative);
+ } catch (BadFlakeRef & e) {
+ return {};
+ }
+}
+
+}
diff --git a/src/libexpr/primops/flakeref.hh b/src/libexpr/primops/flakeref.hh
new file mode 100644
index 000000000..52bb82ddb
--- /dev/null
+++ b/src/libexpr/primops/flakeref.hh
@@ -0,0 +1,188 @@
+#pragma once
+
+#include "types.hh"
+#include "hash.hh"
+
+#include <variant>
+
+namespace nix {
+
+/* Flake references are a URI-like syntax to specify a flake.
+
+ Examples:
+
+ * <flake-id>(/rev-or-ref(/rev)?)?
+
+ Look up a flake by ID in the flake lock file or in the flake
+ registry. These must specify an actual location for the flake
+ using the formats listed below. Note that in pure evaluation
+ mode, the flake registry is empty.
+
+ Optionally, the rev or ref from the dereferenced flake can be
+ overriden. For example,
+
+ nixpkgs/19.09
+
+ uses the "19.09" branch of the nixpkgs' flake GitHub repository,
+ while
+
+ nixpkgs/98a2a5b5370c1e2092d09cb38b9dcff6d98a109f
+
+ uses the specified revision. For Git (rather than GitHub)
+ repositories, both the rev and ref must be given, e.g.
+
+ nixpkgs/19.09/98a2a5b5370c1e2092d09cb38b9dcff6d98a109f
+
+ * github:<owner>/<repo>(/<rev-or-ref>)?
+
+ A repository on GitHub. These differ from Git references in that
+ they're downloaded in a efficient way (via the tarball mechanism)
+ and that they support downloading a specific revision without
+ specifying a branch. <rev-or-ref> is either a commit hash ("rev")
+ or a branch or tag name ("ref"). The default is: "master" if none
+ is specified. Note that in pure evaluation mode, a commit hash
+ must be used.
+
+ Flakes fetched in this manner expose "rev" and "lastModified"
+ attributes, but not "revCount".
+
+ Examples:
+
+ github:edolstra/dwarffs
+ github:edolstra/dwarffs/unstable
+ github:edolstra/dwarffs/41c0c1bf292ea3ac3858ff393b49ca1123dbd553
+
+ * https://<server>/<path>.git(\?attr(&attr)*)?
+ ssh://<server>/<path>.git(\?attr(&attr)*)?
+ git://<server>/<path>.git(\?attr(&attr)*)?
+ file:///<path>(\?attr(&attr)*)?
+
+ where 'attr' is one of:
+ rev=<rev>
+ ref=<ref>
+
+ A Git repository fetched through https. Note that the path must
+ end in ".git". The default for "ref" is "master".
+
+ Examples:
+
+ https://example.org/my/repo.git
+ https://example.org/my/repo.git?ref=release-1.2.3
+ https://example.org/my/repo.git?rev=e72daba8250068216d79d2aeef40d4d95aff6666
+ git://github.com/edolstra/dwarffs.git?ref=flake&rev=2efca4bc9da70fb001b26c3dc858c6397d3c4817
+
+ * /path.git(\?attr(&attr)*)?
+
+ Like file://path.git, but if no "ref" or "rev" is specified, the
+ (possibly dirty) working tree will be used. Using a working tree
+ is not allowed in pure evaluation mode.
+
+ Examples:
+
+ /path/to/my/repo
+ /path/to/my/repo?ref=develop
+ /path/to/my/repo?rev=e72daba8250068216d79d2aeef40d4d95aff6666
+
+ * https://<server>/<path>.tar.xz(?hash=<sri-hash>)
+ file:///<path>.tar.xz(?hash=<sri-hash>)
+
+ A flake distributed as a tarball. In pure evaluation mode, an SRI
+ hash is mandatory. It exposes a "lastModified" attribute, being
+ the newest file inside the tarball.
+
+ Example:
+
+ https://releases.nixos.org/nixos/unstable/nixos-19.03pre167858.f2a1a4e93be/nixexprs.tar.xz
+ https://releases.nixos.org/nixos/unstable/nixos-19.03pre167858.f2a1a4e93be/nixexprs.tar.xz?hash=sha256-56bbc099995ea8581ead78f22832fee7dbcb0a0b6319293d8c2d0aef5379397c
+
+ Note: currently, there can be only one flake per Git repository, and
+ it must be at top-level. In the future, we may want to add a field
+ (e.g. "dir=<dir>") to specify a subdirectory inside the repository.
+*/
+
+typedef std::string FlakeId;
+typedef std::string FlakeAlias;
+typedef std::string FlakeUri;
+
+struct FlakeRef
+{
+ struct IsAlias
+ {
+ FlakeAlias alias;
+ bool operator<(const IsAlias & b) const { return alias < b.alias; };
+ bool operator==(const IsAlias & b) const { return alias == b.alias; };
+ };
+
+ struct IsGitHub {
+ std::string owner, repo;
+ bool operator<(const IsGitHub & b) const {
+ return std::make_tuple(owner, repo) < std::make_tuple(b.owner, b.repo);
+ }
+ bool operator==(const IsGitHub & b) const {
+ return owner == b.owner && repo == b.repo;
+ }
+ };
+
+ // Git, Tarball
+ struct IsGit
+ {
+ std::string uri;
+ bool operator<(const IsGit & b) const { return uri < b.uri; }
+ bool operator==(const IsGit & b) const { return uri == b.uri; }
+ };
+
+ struct IsPath
+ {
+ Path path;
+ bool operator<(const IsPath & b) const { return path < b.path; }
+ bool operator==(const IsPath & b) const { return path == b.path; }
+ };
+
+ // Git, Tarball
+
+ std::variant<IsAlias, IsGitHub, IsGit, IsPath> data;
+
+ std::optional<std::string> ref;
+ std::optional<Hash> rev;
+ Path subdir = ""; // This is a relative path pointing at the flake.nix file's directory, relative to the git root.
+
+ bool operator<(const FlakeRef & flakeRef) const
+ {
+ return std::make_tuple(data, ref, rev, subdir) <
+ std::make_tuple(flakeRef.data, flakeRef.ref, flakeRef.rev, subdir);
+ }
+
+ bool operator==(const FlakeRef & flakeRef) const
+ {
+ return std::make_tuple(data, ref, rev, subdir) ==
+ std::make_tuple(flakeRef.data, flakeRef.ref, flakeRef.rev, flakeRef.subdir);
+ }
+
+ // Parse a flake URI.
+ FlakeRef(const std::string & uri, bool allowRelative = false);
+
+ // FIXME: change to operator <<.
+ std::string to_string() const;
+
+ /* Check whether this is a "direct" flake reference, that is, not
+ a flake ID, which requires a lookup in the flake registry. */
+ bool isDirect() const
+ {
+ return !std::get_if<FlakeRef::IsAlias>(&data);
+ }
+
+ /* Check whether this is an "immutable" flake reference, that is,
+ one that contains a commit hash or content hash. */
+ bool isImmutable() const;
+
+ FlakeRef baseRef() const;
+};
+
+std::ostream & operator << (std::ostream & str, const FlakeRef & flakeRef);
+
+MakeError(BadFlakeRef, Error);
+
+std::optional<FlakeRef> parseFlakeRef(
+ const std::string & uri, bool allowRelative = false);
+
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 13:23:23 +0000