mirror of
https://github.com/NixOS/nix.git
synced 2025-11-10 20:46:01 +01:00
93 lines
2.9 KiB
C++
93 lines
2.9 KiB
C++
#include "nix/store/store-api.hh"
|
|
#include "nix/expr/eval.hh"
|
|
#include "nix/util/mounted-source-accessor.hh"
|
|
#include "nix/fetchers/fetch-to-store.hh"
|
|
|
|
namespace nix {
|
|
|
|
SourcePath EvalState::rootPath(CanonPath path)
|
|
{
|
|
return {rootFS, std::move(path)};
|
|
}
|
|
|
|
SourcePath EvalState::rootPath(PathView path)
|
|
{
|
|
return {rootFS, CanonPath(absPath(path))};
|
|
}
|
|
|
|
SourcePath EvalState::storePath(const StorePath & path)
|
|
{
|
|
return {rootFS, CanonPath{store->printStorePath(path)}};
|
|
}
|
|
|
|
StorePath EvalState::devirtualize(const StorePath & path, StringMap * rewrites)
|
|
{
|
|
if (auto mount = storeFS->getMount(CanonPath(store->printStorePath(path)))) {
|
|
auto storePath = fetchToStore(
|
|
*store, SourcePath{ref(mount)}, settings.readOnlyMode ? FetchMode::DryRun : FetchMode::Copy, path.name());
|
|
assert(storePath.name() == path.name());
|
|
if (rewrites)
|
|
rewrites->emplace(path.hashPart(), storePath.hashPart());
|
|
return storePath;
|
|
} else
|
|
return path;
|
|
}
|
|
|
|
SingleDerivedPath EvalState::devirtualize(const SingleDerivedPath & path, StringMap * rewrites)
|
|
{
|
|
if (auto o = std::get_if<SingleDerivedPath::Opaque>(&path.raw()))
|
|
return SingleDerivedPath::Opaque{devirtualize(o->path, rewrites)};
|
|
else
|
|
return path;
|
|
}
|
|
|
|
std::string EvalState::devirtualize(std::string_view s, const NixStringContext & context)
|
|
{
|
|
StringMap rewrites;
|
|
|
|
for (auto & c : context)
|
|
if (auto o = std::get_if<NixStringContextElem::Opaque>(&c.raw))
|
|
devirtualize(o->path, &rewrites);
|
|
|
|
return rewriteStrings(std::string(s), rewrites);
|
|
}
|
|
|
|
std::string EvalState::computeBaseName(const SourcePath & path)
|
|
{
|
|
if (path.accessor == rootFS) {
|
|
if (auto storePath = store->maybeParseStorePath(path.path.abs())) {
|
|
warn(
|
|
"Performing inefficient double copy of path '%s' to the store. "
|
|
"This can typically be avoided by rewriting an attribute like `src = ./.` "
|
|
"to `src = builtins.path { path = ./.; name = \"source\"; }`.",
|
|
path);
|
|
return std::string(fetchToStore(*store, path, FetchMode::DryRun).to_string());
|
|
}
|
|
}
|
|
return std::string(path.baseName());
|
|
}
|
|
|
|
StorePath EvalState::mountInput(
|
|
fetchers::Input & input, const fetchers::Input & originalInput, ref<SourceAccessor> accessor, bool requireLockable)
|
|
{
|
|
auto storePath = StorePath::random(input.getName());
|
|
|
|
allowPath(storePath); // FIXME: should just whitelist the entire virtual store
|
|
|
|
storeFS->mount(CanonPath(store->printStorePath(storePath)), accessor);
|
|
|
|
if (requireLockable && !input.isLocked() && !input.getNarHash()) {
|
|
auto narHash = accessor->hashPath(CanonPath::root);
|
|
input.attrs.insert_or_assign("narHash", narHash.to_string(HashFormat::SRI, true));
|
|
}
|
|
|
|
// FIXME: check NAR hash
|
|
|
|
#if 0
|
|
assert(!originalInput.getNarHash() || storePath == originalInput.computeStorePath(*store));
|
|
#endif
|
|
|
|
return storePath;
|
|
}
|
|
|
|
}
|