forked from lix-project/lix
30ccf4e52d
Instead of a list, inputs are now an attrset like
inputs = {
nixpkgs.uri = github:NixOS/nixpkgs;
};
If 'uri' is omitted, than the flake is a lookup in the flake registry, e.g.
inputs = {
nixpkgs = {};
};
but in that case, you can also just omit the input altogether and
specify it as an argument to the 'outputs' function, as in
outputs = { self, nixpkgs }: ...
This also gets rid of 'nonFlakeInputs', which are now just a special
kind of input that have a 'flake = false' attribute, e.g.
inputs = {
someRepo = {
uri = github:example/repo;
flake = false;
};
};
123 lines
3 KiB
C++
123 lines
3 KiB
C++
#pragma once
|
|
|
|
#include "types.hh"
|
|
#include "flakeref.hh"
|
|
#include "lockfile.hh"
|
|
|
|
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;
|
|
};
|
|
|
|
typedef std::vector<std::shared_ptr<FlakeRegistry>> Registries;
|
|
|
|
std::shared_ptr<FlakeRegistry> readRegistry(const Path &);
|
|
|
|
void writeRegistry(const FlakeRegistry &, const Path &);
|
|
|
|
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
|
|
};
|
|
|
|
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 FlakeInput
|
|
{
|
|
FlakeRef ref;
|
|
bool isFlake = true;
|
|
FlakeInput(const FlakeRef & ref) : ref(ref) {};
|
|
};
|
|
|
|
struct Flake
|
|
{
|
|
FlakeId id;
|
|
FlakeRef originalRef;
|
|
std::string description;
|
|
SourceInfo sourceInfo;
|
|
std::map<FlakeId, FlakeInput> inputs;
|
|
Value * vOutputs; // FIXME: gc
|
|
unsigned int edition;
|
|
|
|
Flake(const FlakeRef & origRef, const SourceInfo & sourceInfo)
|
|
: originalRef(origRef), sourceInfo(sourceInfo) {};
|
|
};
|
|
|
|
Flake getFlake(EvalState &, const FlakeRef &);
|
|
|
|
/* If 'allowLookup' is true, then resolve 'flakeRef' using the
|
|
registries. */
|
|
FlakeRef maybeLookupFlake(
|
|
EvalState & state,
|
|
const FlakeRef & flakeRef,
|
|
bool allowLookup);
|
|
|
|
/* Fingerprint of a locked flake; used as a cache key. */
|
|
typedef Hash Fingerprint;
|
|
|
|
struct ResolvedFlake
|
|
{
|
|
Flake flake;
|
|
LockFile lockFile;
|
|
|
|
ResolvedFlake(Flake && flake, LockFile && lockFile)
|
|
: flake(flake), lockFile(lockFile) {}
|
|
|
|
Fingerprint getFingerprint() const;
|
|
};
|
|
|
|
ResolvedFlake resolveFlake(EvalState &, const FlakeRef &, HandleLockFile);
|
|
|
|
void callFlake(EvalState & state,
|
|
const Flake & flake,
|
|
const LockedInputs & inputs,
|
|
Value & v);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|