2019-10-14 12:40:16 +00:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "util.hh"
|
2019-12-11 13:53:30 +00:00
|
|
|
#include "path.hh"
|
2021-03-02 00:47:00 +00:00
|
|
|
#include "path-with-outputs.hh"
|
2021-04-05 14:33:28 +00:00
|
|
|
#include "derived-path.hh"
|
2020-02-07 13:22:01 +00:00
|
|
|
#include "eval.hh"
|
2022-03-02 12:54:08 +00:00
|
|
|
#include "store-api.hh"
|
2020-04-20 11:13:52 +00:00
|
|
|
#include "flake/flake.hh"
|
2019-10-14 12:40:16 +00:00
|
|
|
|
|
|
|
#include <optional>
|
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
2019-10-21 22:21:58 +00:00
|
|
|
struct DrvInfo;
|
2019-12-03 23:36:04 +00:00
|
|
|
struct SourceExprCommand;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2020-04-20 13:27:09 +00:00
|
|
|
namespace eval_cache { class EvalCache; class AttrCursor; }
|
2020-04-20 11:13:52 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
struct App
|
|
|
|
{
|
2020-06-29 17:08:50 +00:00
|
|
|
std::vector<StorePathWithOutputs> context;
|
2019-10-14 12:40:16 +00:00
|
|
|
Path program;
|
|
|
|
// FIXME: add args, sandbox settings, metadata, ...
|
|
|
|
};
|
|
|
|
|
2021-05-17 15:49:20 +00:00
|
|
|
struct UnresolvedApp
|
|
|
|
{
|
|
|
|
App unresolved;
|
2021-07-16 14:04:47 +00:00
|
|
|
App resolve(ref<Store> evalStore, ref<Store> store);
|
2021-05-17 15:49:20 +00:00
|
|
|
};
|
|
|
|
|
2022-03-02 12:54:08 +00:00
|
|
|
enum class Realise {
|
|
|
|
/* Build the derivation. Postcondition: the
|
|
|
|
derivation outputs exist. */
|
|
|
|
Outputs,
|
|
|
|
/* Don't build the derivation. Postcondition: the store derivation
|
|
|
|
exists. */
|
|
|
|
Derivation,
|
|
|
|
/* Evaluate in dry-run mode. Postcondition: nothing. */
|
|
|
|
// FIXME: currently unused, but could be revived if we can
|
|
|
|
// evaluate derivations in-memory.
|
|
|
|
Nothing
|
|
|
|
};
|
|
|
|
|
|
|
|
/* How to handle derivations in commands that operate on store paths. */
|
|
|
|
enum class OperateOn {
|
|
|
|
/* Operate on the output path. */
|
|
|
|
Output,
|
|
|
|
/* Operate on the .drv path. */
|
|
|
|
Derivation
|
|
|
|
};
|
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
struct Installable
|
|
|
|
{
|
|
|
|
virtual ~Installable() { }
|
|
|
|
|
2022-01-18 16:28:18 +00:00
|
|
|
virtual std::string what() const = 0;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2021-05-17 06:45:08 +00:00
|
|
|
virtual DerivedPaths toDerivedPaths() = 0;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2022-01-18 16:28:18 +00:00
|
|
|
virtual StorePathSet toDrvPaths(ref<Store> store)
|
|
|
|
{
|
|
|
|
throw Error("'%s' cannot be converted to a derivation path", what());
|
|
|
|
}
|
|
|
|
|
2021-05-17 06:45:08 +00:00
|
|
|
DerivedPath toDerivedPath();
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2021-05-17 15:49:20 +00:00
|
|
|
UnresolvedApp toApp(EvalState & state);
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
virtual std::pair<Value *, PosIdx> toValue(EvalState & state)
|
2019-10-14 12:40:16 +00:00
|
|
|
{
|
|
|
|
throw Error("argument '%s' cannot be evaluated", what());
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return a value only if this installable is a store path or a
|
|
|
|
symlink to it. */
|
2019-12-11 13:53:30 +00:00
|
|
|
virtual std::optional<StorePath> getStorePath()
|
2019-10-14 12:40:16 +00:00
|
|
|
{
|
|
|
|
return {};
|
|
|
|
}
|
2020-04-20 13:27:09 +00:00
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
virtual std::vector<ref<eval_cache::AttrCursor>>
|
2020-08-07 12:13:24 +00:00
|
|
|
getCursors(EvalState & state);
|
2020-06-04 18:02:50 +00:00
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
virtual ref<eval_cache::AttrCursor>
|
2020-08-07 12:13:24 +00:00
|
|
|
getCursor(EvalState & state);
|
2020-05-05 16:49:39 +00:00
|
|
|
|
|
|
|
virtual FlakeRef nixpkgsFlakeRef() const
|
|
|
|
{
|
2020-09-08 12:50:23 +00:00
|
|
|
return FlakeRef::fromAttrs({{"type","indirect"}, {"id", "nixpkgs"}});
|
2020-05-05 16:49:39 +00:00
|
|
|
}
|
2022-03-02 12:54:08 +00:00
|
|
|
|
|
|
|
static BuiltPaths build(
|
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables,
|
|
|
|
BuildMode bMode = bmNormal);
|
|
|
|
|
2022-03-28 12:21:35 +00:00
|
|
|
static std::vector<std::pair<std::shared_ptr<Installable>, BuiltPath>> build2(
|
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables,
|
|
|
|
BuildMode bMode = bmNormal);
|
|
|
|
|
2022-03-02 12:54:08 +00:00
|
|
|
static std::set<StorePath> toStorePaths(
|
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
OperateOn operateOn,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables);
|
|
|
|
|
|
|
|
static StorePath toStorePath(
|
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
OperateOn operateOn,
|
|
|
|
std::shared_ptr<Installable> installable);
|
|
|
|
|
|
|
|
static std::set<StorePath> toDerivations(
|
|
|
|
ref<Store> store,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables,
|
|
|
|
bool useDeriver = false);
|
|
|
|
|
|
|
|
static BuiltPaths toBuiltPaths(
|
|
|
|
ref<Store> evalStore,
|
|
|
|
ref<Store> store,
|
|
|
|
Realise mode,
|
|
|
|
OperateOn operateOn,
|
|
|
|
const std::vector<std::shared_ptr<Installable>> & installables);
|
2019-10-14 12:40:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct InstallableValue : Installable
|
|
|
|
{
|
2020-05-09 15:35:33 +00:00
|
|
|
ref<EvalState> state;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2020-05-09 15:35:33 +00:00
|
|
|
InstallableValue(ref<EvalState> state) : state(state) {}
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
struct DerivationInfo
|
|
|
|
{
|
|
|
|
StorePath drvPath;
|
2022-04-20 14:39:47 +00:00
|
|
|
std::set<std::string> outputsToInstall;
|
2022-05-13 20:02:28 +00:00
|
|
|
std::optional<NixInt> priority;
|
2020-04-20 11:13:52 +00:00
|
|
|
};
|
|
|
|
|
2020-05-09 15:35:33 +00:00
|
|
|
virtual std::vector<DerivationInfo> toDerivations() = 0;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2021-05-17 06:45:08 +00:00
|
|
|
DerivedPaths toDerivedPaths() override;
|
2022-01-18 16:28:18 +00:00
|
|
|
|
|
|
|
StorePathSet toDrvPaths(ref<Store> store) override;
|
2019-10-14 12:40:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct InstallableFlake : InstallableValue
|
|
|
|
{
|
|
|
|
FlakeRef flakeRef;
|
|
|
|
Strings attrPaths;
|
|
|
|
Strings prefixes;
|
2022-04-22 13:17:01 +00:00
|
|
|
OutputsSpec outputsSpec;
|
2020-05-09 15:35:33 +00:00
|
|
|
const flake::LockFlags & lockFlags;
|
2020-05-13 05:45:45 +00:00
|
|
|
mutable std::shared_ptr<flake::LockedFlake> _lockedFlake;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2021-02-17 16:32:10 +00:00
|
|
|
InstallableFlake(
|
|
|
|
SourceExprCommand * cmd,
|
|
|
|
ref<EvalState> state,
|
|
|
|
FlakeRef && flakeRef,
|
2022-02-14 19:39:44 +00:00
|
|
|
std::string_view fragment,
|
2022-04-22 13:17:01 +00:00
|
|
|
OutputsSpec outputsSpec,
|
2022-02-14 19:39:44 +00:00
|
|
|
Strings attrPaths,
|
|
|
|
Strings prefixes,
|
2021-02-17 16:32:10 +00:00
|
|
|
const flake::LockFlags & lockFlags);
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2022-01-18 16:28:18 +00:00
|
|
|
std::string what() const override { return flakeRef.to_string() + "#" + *attrPaths.begin(); }
|
2019-10-14 12:40:16 +00:00
|
|
|
|
|
|
|
std::vector<std::string> getActualAttrPaths();
|
|
|
|
|
2020-01-22 19:59:59 +00:00
|
|
|
Value * getFlakeOutputs(EvalState & state, const flake::LockedFlake & lockedFlake);
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2022-05-16 13:17:35 +00:00
|
|
|
std::tuple<std::string, FlakeRef, DerivationInfo> toDerivation();
|
2019-10-21 22:21:58 +00:00
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
std::vector<DerivationInfo> toDerivations() override;
|
2019-10-14 12:40:16 +00:00
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
std::pair<Value *, PosIdx> toValue(EvalState & state) override;
|
2020-04-20 13:27:09 +00:00
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
/* Get a cursor to every attrpath in getActualAttrPaths() that
|
|
|
|
exists. */
|
|
|
|
std::vector<ref<eval_cache::AttrCursor>>
|
2020-08-07 12:13:24 +00:00
|
|
|
getCursors(EvalState & state) override;
|
2020-05-05 16:49:39 +00:00
|
|
|
|
2022-04-14 12:04:19 +00:00
|
|
|
/* Get a cursor to the first attrpath in getActualAttrPaths() that
|
|
|
|
exists, or throw an exception with suggestions if none exists. */
|
|
|
|
ref<eval_cache::AttrCursor> getCursor(EvalState & state) override;
|
|
|
|
|
2020-05-13 05:45:45 +00:00
|
|
|
std::shared_ptr<flake::LockedFlake> getLockedFlake() const;
|
|
|
|
|
2020-05-05 16:49:39 +00:00
|
|
|
FlakeRef nixpkgsFlakeRef() const override;
|
2019-10-14 12:40:16 +00:00
|
|
|
};
|
|
|
|
|
2020-04-20 11:13:52 +00:00
|
|
|
ref<eval_cache::EvalCache> openEvalCache(
|
|
|
|
EvalState & state,
|
2020-08-07 12:13:24 +00:00
|
|
|
std::shared_ptr<flake::LockedFlake> lockedFlake);
|
2020-04-20 11:13:52 +00:00
|
|
|
|
2019-10-14 12:40:16 +00:00
|
|
|
}
|