paths.cc

#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(
            fetchSettings,
            *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, PosIdx pos)
{
    if (path.accessor == rootFS) {
        if (auto storePath = store->maybeParseStorePath(path.path.abs())) {
            debug(
                "Copying '%s' to the store again.\n"
                "You can make Nix evaluate faster and copy fewer files by replacing `./.` with the `self` flake input, "
                "or `builtins.path { path = ./.; name = \"source\"; }`.\n",
                path);
            return std::string(
                fetchToStore(fetchSettings, *store, path, FetchMode::DryRun, storePath->name()).to_string());
        }
    }
    return std::string(path.baseName());
}

StorePath EvalState::mountInput(
    fetchers::Input & input,
    const fetchers::Input & originalInput,
    ref<SourceAccessor> accessor,
    bool requireLockable,
    bool forceNarHash)
{
    auto storePath = settings.lazyTrees
                         ? StorePath::random(input.getName())
                         : fetchToStore(fetchSettings, *store, accessor, FetchMode::Copy, input.getName());

    allowPath(storePath); // FIXME: should just whitelist the entire virtual store

    std::optional<Hash> _narHash;

    auto getNarHash = [&]() {
        if (!_narHash) {
            if (store->isValidPath(storePath))
                _narHash = store->queryPathInfo(storePath)->narHash;
            else
                _narHash = fetchToStore2(fetchSettings, *store, accessor, FetchMode::DryRun, input.getName()).second;
        }
        return _narHash;
    };

    storeFS->mount(CanonPath(store->printStorePath(storePath)), accessor);

    if (forceNarHash
        || (requireLockable && (!settings.lazyTrees || !settings.lazyLocks || !input.isLocked())
            && !input.getNarHash()))
        input.attrs.insert_or_assign("narHash", getNarHash()->to_string(HashFormat::SRI, true));

    if (originalInput.getNarHash() && *getNarHash() != *originalInput.getNarHash())
        throw Error(
            (unsigned int) 102,
            "NAR hash mismatch in input '%s', expected '%s' but got '%s'",
            originalInput.to_string(),
            getNarHash()->to_string(HashFormat::SRI, true),
            originalInput.getNarHash()->to_string(HashFormat::SRI, true));

    return storePath;
}

} // namespace nix