lix/src/libstore/profiles.cc

302 lines
7.9 KiB
C++
Raw Normal View History

2004-02-06 14:57:10 +00:00
#include "profiles.hh"
#include "store-api.hh"
#include "local-fs-store.hh"
#include "util.hh"
2004-02-06 14:57:10 +00:00
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
2004-07-01 11:11:16 +00:00
#include <errno.h>
2005-05-04 16:33:20 +00:00
#include <stdio.h>
2004-02-06 14:57:10 +00:00
namespace nix {
/* Parse a generation name of the format
`<profilename>-<number>-link'. */
2020-07-16 13:14:22 +00:00
static std::optional<GenerationNumber> parseName(const string & profileName, const string & name)
{
2020-07-16 13:14:22 +00:00
if (string(name, 0, profileName.size() + 1) != profileName + "-") return {};
string s = string(name, profileName.size() + 1);
string::size_type p = s.find("-link");
2020-07-16 13:14:22 +00:00
if (p == string::npos) return {};
2021-01-08 11:22:21 +00:00
if (auto n = string2Int<unsigned int>(s.substr(0, p)))
return *n;
else
2020-07-16 13:14:22 +00:00
return {};
}
2020-07-16 13:14:22 +00:00
std::pair<Generations, std::optional<GenerationNumber>> findGenerations(Path profile)
2004-02-06 14:57:10 +00:00
{
Generations gens;
2004-02-06 14:57:10 +00:00
Path profileDir = dirOf(profile);
auto profileName = std::string(baseNameOf(profile));
2012-12-03 17:19:49 +00:00
for (auto & i : readDirectory(profileDir)) {
2020-07-16 13:14:22 +00:00
if (auto n = parseName(profileName, i.name)) {
auto path = profileDir + "/" + i.name;
gens.push_back({
.number = *n,
.path = path,
2020-09-23 17:17:28 +00:00
.creationTime = lstat(path).st_mtime
2020-07-16 13:14:22 +00:00
});
}
2004-02-06 14:57:10 +00:00
}
2020-07-16 13:14:22 +00:00
gens.sort([](const Generation & a, const Generation & b)
{
return a.number < b.number;
});
2020-07-16 13:14:22 +00:00
return {
gens,
pathExists(profile)
? parseName(profileName, readLink(profile))
2020-07-16 13:14:22 +00:00
: std::nullopt
};
}
2020-07-16 13:14:22 +00:00
static void makeName(const Path & profile, GenerationNumber num,
Path & outLink)
{
Path prefix = (format("%1%-%2%") % profile % num).str();
outLink = prefix + "-link";
}
2020-09-03 09:06:56 +00:00
Path createGeneration(ref<LocalFSStore> store, Path profile, StorePath outPath)
{
/* The new generation number should be higher than old the
previous ones. */
2020-07-16 13:14:22 +00:00
auto [gens, dummy] = findGenerations(profile);
2020-07-16 13:14:22 +00:00
GenerationNumber num;
if (gens.size() > 0) {
Generation last = gens.back();
2020-09-03 09:06:56 +00:00
if (readLink(last.path) == store->printStorePath(outPath)) {
/* We only create a new generation symlink if it differs
from the last one.
This helps keeping gratuitous installs/rebuilds from piling
up uncontrolled numbers of generations, cluttering up the
UI like grub. */
return last.path;
}
num = gens.back().number;
} else {
num = 0;
}
/* Create the new generation. Note that addPermRoot() blocks if
the garbage collector is running to prevent the stuff we've
built from moving from the temporary roots (which the GC knows)
to the permanent roots (of which the GC would have a stale
view). If we didn't do it this way, the GC might remove the
user environment etc. we've just built. */
Path generation;
makeName(profile, num + 1, generation);
2020-09-03 09:26:36 +00:00
store->addPermRoot(outPath, generation);
return generation;
2004-02-06 14:57:10 +00:00
}
static void removeFile(const Path & path)
{
if (remove(path.c_str()) == -1)
throw SysError("cannot unlink '%1%'", path);
}
2020-07-16 13:14:22 +00:00
void deleteGeneration(const Path & profile, GenerationNumber gen)
{
Path generation;
makeName(profile, gen, generation);
removeFile(generation);
}
2020-07-16 13:14:22 +00:00
static void deleteGeneration2(const Path & profile, GenerationNumber gen, bool dryRun)
{
if (dryRun)
printInfo(format("would remove generation %1%") % gen);
else {
printInfo(format("removing generation %1%") % gen);
deleteGeneration(profile, gen);
}
}
2020-07-16 13:14:22 +00:00
void deleteGenerations(const Path & profile, const std::set<GenerationNumber> & gensToDelete, bool dryRun)
{
PathLocks lock;
lockProfile(lock, profile);
2020-07-16 13:14:22 +00:00
auto [gens, curGen] = findGenerations(profile);
2020-07-16 13:14:22 +00:00
if (gensToDelete.count(*curGen))
throw Error("cannot delete current generation of profile %1%'", profile);
for (auto & i : gens) {
2020-07-16 13:14:22 +00:00
if (!gensToDelete.count(i.number)) continue;
deleteGeneration2(profile, i.number, dryRun);
}
}
2020-07-16 13:14:22 +00:00
void deleteGenerationsGreaterThan(const Path & profile, GenerationNumber max, bool dryRun)
{
PathLocks lock;
lockProfile(lock, profile);
bool fromCurGen = false;
2020-07-16 13:14:22 +00:00
auto [gens, curGen] = findGenerations(profile);
for (auto i = gens.rbegin(); i != gens.rend(); ++i) {
if (i->number == curGen) {
fromCurGen = true;
max--;
continue;
}
if (fromCurGen) {
if (max) {
max--;
continue;
}
deleteGeneration2(profile, i->number, dryRun);
}
}
}
void deleteOldGenerations(const Path & profile, bool dryRun)
{
PathLocks lock;
lockProfile(lock, profile);
2020-07-16 13:14:22 +00:00
auto [gens, curGen] = findGenerations(profile);
for (auto & i : gens)
if (i.number != curGen)
deleteGeneration2(profile, i.number, dryRun);
}
void deleteGenerationsOlderThan(const Path & profile, time_t t, bool dryRun)
{
PathLocks lock;
lockProfile(lock, profile);
2020-07-16 13:14:22 +00:00
auto [gens, curGen] = findGenerations(profile);
bool canDelete = false;
for (auto i = gens.rbegin(); i != gens.rend(); ++i)
if (canDelete) {
assert(i->creationTime < t);
if (i->number != curGen)
deleteGeneration2(profile, i->number, dryRun);
} else if (i->creationTime < t) {
/* We may now start deleting generations, but we don't
delete this generation yet, because this generation was
still the one that was active at the requested point in
time. */
canDelete = true;
}
}
void deleteGenerationsOlderThan(const Path & profile, const string & timeSpec, bool dryRun)
{
if (timeSpec.empty() || timeSpec[timeSpec.size() - 1] != 'd')
2021-07-12 13:04:46 +00:00
throw UsageError("invalid number of days specifier '%1%', expected something like '14d'", timeSpec);
time_t curTime = time(0);
string strDays = string(timeSpec, 0, timeSpec.size() - 1);
2021-01-08 11:22:21 +00:00
auto days = string2Int<int>(strDays);
2021-01-08 11:22:21 +00:00
if (!days || *days < 1)
2021-07-12 13:04:46 +00:00
throw UsageError("invalid number of days specifier '%1%'", timeSpec);
2021-01-08 11:22:21 +00:00
time_t oldTime = curTime - *days * 24 * 3600;
deleteGenerationsOlderThan(profile, oldTime, dryRun);
}
2004-02-06 14:57:10 +00:00
void switchLink(Path link, Path target)
{
/* Hacky. */
if (dirOf(target) == dirOf(link)) target = baseNameOf(target);
2012-12-03 17:19:49 +00:00
replaceSymlink(target, link);
2004-02-06 14:57:10 +00:00
}
2021-09-14 17:05:28 +00:00
void switchGeneration(
const Path & profile,
std::optional<GenerationNumber> dstGen,
bool dryRun)
{
PathLocks lock;
lockProfile(lock, profile);
auto [gens, curGen] = findGenerations(profile);
std::optional<Generation> dst;
for (auto & i : gens)
if ((!dstGen && i.number < curGen) ||
(dstGen && i.number == *dstGen))
dst = i;
if (!dst) {
if (dstGen)
throw Error("generation %1% does not exist", *dstGen);
else
throw Error("no generation older than the current (%1%) exists", curGen.value_or(0));
}
notice("switching from generation %d to %d", curGen.value_or(0), dst->number);
if (dryRun) return;
switchLink(profile, dst->path);
}
void lockProfile(PathLocks & lock, const Path & profile)
{
lock.lockPaths({profile}, (format("waiting for lock on profile '%1%'") % profile).str());
lock.setDeletion(true);
}
string optimisticLockProfile(const Path & profile)
{
return pathExists(profile) ? readLink(profile) : "";
}
2020-03-24 13:26:13 +00:00
Path getDefaultProfile()
{
Path profileLink = getHome() + "/.nix-profile";
try {
if (!pathExists(profileLink)) {
replaceSymlink(
getuid() == 0
? settings.nixStateDir + "/profiles/default"
: fmt("%s/profiles/per-user/%s/profile", settings.nixStateDir, getUserName()),
profileLink);
}
return absPath(readLink(profileLink), dirOf(profileLink));
} catch (Error &) {
return profileLink;
}
}
}