1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
#include "nix-env/user-env.hh"
#include <glog/logging.h>
#include "libexpr/eval-inline.hh"
#include "libexpr/eval.hh"
#include "libmain/shared.hh"
#include "libstore/derivations.hh"
#include "libstore/globals.hh"
#include "libstore/profiles.hh"
#include "libstore/store-api.hh"
#include "libutil/util.hh"
namespace nix {
DrvInfos queryInstalled(EvalState& state, const Path& userEnv) {
DrvInfos elems;
Path manifestFile = userEnv + "/manifest.nix";
if (pathExists(manifestFile)) {
Value v{};
state.evalFile(manifestFile, v);
Bindings& bindings(*Bindings::NewGC());
getDerivations(state, v, "", bindings, elems, false);
}
return elems;
}
bool createUserEnv(EvalState& state, DrvInfos& elems, const Path& profile,
bool keepDerivations, const std::string& lockToken) {
/* Build the components in the user environment, if they don't
exist already. */
PathSet drvsToBuild;
for (auto& i : elems) {
if (!i.queryDrvPath().empty()) {
drvsToBuild.insert(i.queryDrvPath());
}
}
DLOG(INFO) << "building user environment dependencies";
state.store->buildPaths(drvsToBuild,
state.repair != 0u ? bmRepair : bmNormal);
/* Construct the whole top level derivation. */
PathSet references;
Value manifest{};
state.mkList(manifest, elems.size());
unsigned int n = 0;
for (auto& i : elems) {
/* Create a pseudo-derivation containing the name, system,
output paths, and optionally the derivation path, as well
as the meta attributes. */
Path drvPath = keepDerivations ? i.queryDrvPath() : "";
Value* v = state.allocValue();
(*manifest.list)[n++] = v;
state.mkAttrs(*v, 16);
mkString(*state.allocAttr(*v, state.sType), "derivation");
mkString(*state.allocAttr(*v, state.sName), i.queryName());
auto system = i.querySystem();
if (!system.empty()) {
mkString(*state.allocAttr(*v, state.sSystem), system);
}
mkString(*state.allocAttr(*v, state.sOutPath), i.queryOutPath());
if (!drvPath.empty()) {
mkString(*state.allocAttr(*v, state.sDrvPath), i.queryDrvPath());
}
// Copy each output meant for installation.
DrvInfo::Outputs outputs = i.queryOutputs(true);
Value& vOutputs = *state.allocAttr(*v, state.sOutputs);
state.mkList(vOutputs, outputs.size());
unsigned int m = 0;
for (auto& j : outputs) {
mkString(*((*vOutputs.list)[m++] = state.allocValue()), j.first);
Value& vOutputs = *state.allocAttr(*v, state.symbols.Create(j.first));
state.mkAttrs(vOutputs, 2);
mkString(*state.allocAttr(vOutputs, state.sOutPath), j.second);
/* This is only necessary when installing store paths, e.g.,
`nix-env -i /nix/store/abcd...-foo'. */
state.store->addTempRoot(j.second);
state.store->ensurePath(j.second);
references.insert(j.second);
}
// Copy the meta attributes.
Value& vMeta = *state.allocAttr(*v, state.sMeta);
state.mkAttrs(vMeta, 16);
StringSet metaNames = i.queryMetaNames();
for (auto& j : metaNames) {
Value* v = i.queryMeta(j);
if (v == nullptr) {
continue;
}
vMeta.attrs->push_back(Attr(state.symbols.Create(j), v));
}
if (!drvPath.empty()) {
references.insert(drvPath);
}
}
/* Also write a copy of the list of user environment elements to
the store; we need it for future modifications of the
environment. */
Path manifestFile = state.store->addTextToStore(
"env-manifest.nix", (format("%1%") % manifest).str(), references);
/* Get the environment builder expression. */
Value envBuilder{};
state.evalFile(state.findFile("nix/buildenv.nix"), envBuilder);
/* Construct a Nix expression that calls the user environment
builder with the manifest as argument. */
Value args{};
Value topLevel{};
state.mkAttrs(args, 3);
mkString(*state.allocAttr(args, state.symbols.Create("manifest")),
manifestFile, {manifestFile});
args.attrs->push_back(Attr(state.symbols.Create("derivations"), &manifest));
mkApp(topLevel, envBuilder, args);
/* Evaluate it. */
DLOG(INFO) << "evaluating user environment builder";
state.forceValue(topLevel);
PathSet context;
Attr& aDrvPath(topLevel.attrs->find(state.sDrvPath)->second);
Path topLevelDrv =
state.coerceToPath(aDrvPath.pos != nullptr ? *(aDrvPath.pos) : noPos,
*(aDrvPath.value), context);
Attr& aOutPath(topLevel.attrs->find(state.sOutPath)->second);
Path topLevelOut =
state.coerceToPath(aOutPath.pos != nullptr ? *(aOutPath.pos) : noPos,
*(aOutPath.value), context);
/* Realise the resulting store expression. */
DLOG(INFO) << "building user environment";
state.store->buildPaths({topLevelDrv},
state.repair != 0u ? bmRepair : bmNormal);
/* Switch the current user environment to the output path. */
auto store2 = state.store.dynamic_pointer_cast<LocalFSStore>();
if (store2) {
PathLocks lock;
lockProfile(lock, profile);
Path lockTokenCur = optimisticLockProfile(profile);
if (lockToken != lockTokenCur) {
LOG(WARNING) << "profile '" << profile
<< "' changed while we were busy; restarting";
return false;
}
DLOG(INFO) << "switching to new user environment";
Path generation =
createGeneration(ref<LocalFSStore>(store2), profile, topLevelOut);
switchLink(profile, generation);
}
return true;
}
} // namespace nix
|
