Qyriad
6881476232
nix::fetchers::CacheImpl uses $XDG_CACHE_HOME, or its default based on
$HOME, to store its SQLite database. If the current process can't write
to that directory for whatever reason, though, any eval-time fetching
would fail just initializing the cache.
With this change, IO errors initializing the fetcher cache are logged
but ignored, and nix::fetchers::CacheImpl falls back to an in-memory¹
database instead.
Notably, this will fix any uses eval fetching while Lix itself is being
run in a derivation builder (such as during tests), as the derivation
builder does not set $XDG_CACHE_HOME, and sets $HOME to the non-existent
directory /homeless-shelter.
Before:
$ env -u XDG_CACHE_HOME HOME=/homeless-shelter nix -Lv eval --impure -E 'fetchTarball "https://git.lix.systems/lix-project/lix/archive/main.tar.gz"'
error:
… while calling the 'fetchTarball' builtin
at «string»:1:1:
1| fetchTarball "https://git.lix.systems/lix-project/lix/archive/main.tar.gz"
| ^
error: creating directory '/homeless-shelter': Permission denied
After:
$ env -u XDG_CACHE_HOME HOME=/homeless-shelter nix -Lv eval --impure -E 'fetchTarball "https://git.lix.systems/lix-project/lix/archive/main.tar.gz"'
warning: ignoring error initializing Lix fetcher cache: error: creating directory '/homeless-shelter': Permission denied
"/nix/store/s9lxdnn0awp37n560bg4fgr497ah4hvw-source"
¹: https://www.sqlite.org/inmemorydb.html
Change-Id: I15c38c9baaf215fc6e192b8a4c70b9692a69bc22
131 lines
3.6 KiB
C++
131 lines
3.6 KiB
C++
#include "cache.hh"
|
|
#include "sqlite.hh"
|
|
#include "sync.hh"
|
|
#include "store-api.hh"
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
namespace nix::fetchers {
|
|
|
|
static const char * schema = R"sql(
|
|
|
|
create table if not exists Cache (
|
|
input text not null,
|
|
info text not null,
|
|
path text not null,
|
|
immutable integer not null,
|
|
timestamp integer not null,
|
|
primary key (input)
|
|
);
|
|
)sql";
|
|
|
|
struct CacheImpl : Cache
|
|
{
|
|
struct State
|
|
{
|
|
SQLite db;
|
|
SQLiteStmt add, lookup;
|
|
};
|
|
|
|
Sync<State> _state;
|
|
|
|
CacheImpl()
|
|
{
|
|
auto state(_state.lock());
|
|
|
|
auto dbPath = getCacheDir() + "/nix/fetcher-cache-v1.sqlite";
|
|
// It would be silly to fail fetcher operations if e.g. the user has no
|
|
// XDG_CACHE_HOME and their HOME directory doesn't exist.
|
|
// We'll warn the user if that happens, but fallback to an in-memory
|
|
// backend for the SQLite database.
|
|
try {
|
|
createDirs(dirOf(dbPath));
|
|
} catch (SysError const & ex) {
|
|
warn("ignoring error initializing Lix fetcher cache: %s", ex.what());
|
|
dbPath = ":memory:";
|
|
}
|
|
|
|
state->db = SQLite(dbPath);
|
|
state->db.isCache();
|
|
state->db.exec(schema);
|
|
|
|
state->add.create(state->db,
|
|
"insert or replace into Cache(input, info, path, immutable, timestamp) values (?, ?, ?, ?, ?)");
|
|
|
|
state->lookup.create(state->db,
|
|
"select info, path, immutable, timestamp from Cache where input = ?");
|
|
}
|
|
|
|
void add(
|
|
ref<Store> store,
|
|
const Attrs & inAttrs,
|
|
const Attrs & infoAttrs,
|
|
const StorePath & storePath,
|
|
bool locked) override
|
|
{
|
|
_state.lock()->add.use()
|
|
(attrsToJSON(inAttrs).dump())
|
|
(attrsToJSON(infoAttrs).dump())
|
|
(store->printStorePath(storePath))
|
|
(locked)
|
|
(time(0)).exec();
|
|
}
|
|
|
|
std::optional<std::pair<Attrs, StorePath>> lookup(
|
|
ref<Store> store,
|
|
const Attrs & inAttrs) override
|
|
{
|
|
if (auto res = lookupExpired(store, inAttrs)) {
|
|
if (!res->expired)
|
|
return std::make_pair(std::move(res->infoAttrs), std::move(res->storePath));
|
|
debug("ignoring expired cache entry '%s'",
|
|
attrsToJSON(inAttrs).dump());
|
|
}
|
|
return {};
|
|
}
|
|
|
|
std::optional<Result> lookupExpired(
|
|
ref<Store> store,
|
|
const Attrs & inAttrs) override
|
|
{
|
|
auto state(_state.lock());
|
|
|
|
auto inAttrsJSON = attrsToJSON(inAttrs).dump();
|
|
|
|
auto stmt(state->lookup.use()(inAttrsJSON));
|
|
if (!stmt.next()) {
|
|
debug("did not find cache entry for '%s'", inAttrsJSON);
|
|
return {};
|
|
}
|
|
|
|
auto infoJSON = stmt.getStr(0);
|
|
auto storePath = store->parseStorePath(stmt.getStr(1));
|
|
auto locked = stmt.getInt(2) != 0;
|
|
auto timestamp = stmt.getInt(3);
|
|
|
|
store->addTempRoot(storePath);
|
|
if (!store->isValidPath(storePath)) {
|
|
// FIXME: we could try to substitute 'storePath'.
|
|
debug("ignoring disappeared cache entry '%s'", inAttrsJSON);
|
|
return {};
|
|
}
|
|
|
|
debug("using cache entry '%s' -> '%s', '%s'",
|
|
inAttrsJSON, infoJSON, store->printStorePath(storePath));
|
|
|
|
return Result {
|
|
.expired = !locked && (settings.tarballTtl.get() == 0 || timestamp + settings.tarballTtl < time(0)),
|
|
.infoAttrs = jsonToAttrs(nlohmann::json::parse(infoJSON)),
|
|
.storePath = std::move(storePath)
|
|
};
|
|
}
|
|
};
|
|
|
|
ref<Cache> getCache()
|
|
{
|
|
static auto cache = std::make_shared<CacheImpl>();
|
|
return ref<Cache>(cache);
|
|
}
|
|
|
|
}
|