2012-07-18 18:59:03 +00:00
|
|
|
|
#pragma once
|
2023-04-01 03:18:41 +00:00
|
|
|
|
///@file
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2016-03-30 11:27:25 +00:00
|
|
|
|
#include "sqlite.hh"
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2016-03-30 11:27:25 +00:00
|
|
|
|
#include "pathlocks.hh"
|
2006-11-30 17:43:04 +00:00
|
|
|
|
#include "store-api.hh"
|
2023-03-23 14:06:45 +00:00
|
|
|
|
#include "indirect-root-store.hh"
|
2016-04-08 16:07:13 +00:00
|
|
|
|
#include "sync.hh"
|
2008-06-09 13:52:45 +00:00
|
|
|
|
#include "util.hh"
|
2010-02-18 13:16:59 +00:00
|
|
|
|
|
2017-09-05 18:43:42 +00:00
|
|
|
|
#include <chrono>
|
|
|
|
|
#include <future>
|
2016-04-08 16:07:13 +00:00
|
|
|
|
#include <string>
|
|
|
|
|
#include <unordered_set>
|
|
|
|
|
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Nix store and database schema version.
|
|
|
|
|
*
|
|
|
|
|
* Version 1 (or 0) was Nix <=
|
|
|
|
|
* 0.7. Version 2 was Nix 0.8 and 0.9. Version 3 is Nix 0.10.
|
|
|
|
|
* Version 4 is Nix 0.11. Version 5 is Nix 0.12-0.16. Version 6 is
|
|
|
|
|
* Nix 1.0. Version 7 is Nix 1.3. Version 10 is 2.0.
|
|
|
|
|
*/
|
2016-08-03 11:17:11 +00:00
|
|
|
|
const int nixSchemaVersion = 10;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
|
|
|
|
|
2007-10-09 22:14:27 +00:00
|
|
|
|
struct OptimiseStats
|
|
|
|
|
{
|
2017-04-10 09:12:45 +00:00
|
|
|
|
unsigned long filesLinked = 0;
|
2020-07-30 11:10:49 +00:00
|
|
|
|
uint64_t bytesFreed = 0;
|
|
|
|
|
uint64_t blocksFreed = 0;
|
2007-10-09 22:14:27 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-09-11 09:06:18 +00:00
|
|
|
|
struct LocalStoreConfig : virtual LocalFSStoreConfig
|
|
|
|
|
{
|
|
|
|
|
using LocalFSStoreConfig::LocalFSStoreConfig;
|
|
|
|
|
|
2024-03-04 04:24:33 +00:00
|
|
|
|
Setting<bool> requireSigs{this,
|
2020-09-11 09:06:18 +00:00
|
|
|
|
settings.requireSigs,
|
2023-03-22 13:23:36 +00:00
|
|
|
|
"require-sigs",
|
|
|
|
|
"Whether store paths copied into this store should have a trusted signature."};
|
2020-09-14 12:04:02 +00:00
|
|
|
|
|
2024-03-04 04:24:33 +00:00
|
|
|
|
Setting<bool> readOnly{this,
|
2023-06-20 09:34:09 +00:00
|
|
|
|
false,
|
|
|
|
|
"read-only",
|
|
|
|
|
R"(
|
|
|
|
|
Allow this store to be opened when its [database](@docroot@/glossary.md#gloss-nix-database) is on a read-only filesystem.
|
|
|
|
|
|
|
|
|
|
Normally Nix will attempt to open the store database in read-write mode, even for querying (when write access is not needed), causing it to fail if the database is on a read-only filesystem.
|
|
|
|
|
|
|
|
|
|
Enable read-only mode to disable locking and open the SQLite database with the [`immutable` parameter](https://www.sqlite.org/c3ref/open.html) set.
|
|
|
|
|
|
|
|
|
|
> **Warning**
|
|
|
|
|
> Do not use this unless the filesystem is read-only.
|
|
|
|
|
>
|
|
|
|
|
> Using it when the filesystem is writable can cause incorrect query results or corruption errors if the database is changed by another process.
|
|
|
|
|
> While the filesystem the database resides on might appear to be read-only, consider whether another user or system might have write access to it.
|
|
|
|
|
)"};
|
|
|
|
|
|
2020-09-14 12:04:02 +00:00
|
|
|
|
const std::string name() override { return "Local Store"; }
|
2007-10-09 22:14:27 +00:00
|
|
|
|
|
2023-03-21 13:03:05 +00:00
|
|
|
|
std::string doc() override;
|
|
|
|
|
};
|
2007-10-09 22:14:27 +00:00
|
|
|
|
|
2023-03-23 14:06:45 +00:00
|
|
|
|
class LocalStore : public virtual LocalStoreConfig
|
|
|
|
|
, public virtual IndirectRootStore
|
|
|
|
|
, public virtual GcStore
|
2006-11-30 17:43:04 +00:00
|
|
|
|
{
|
2007-08-12 00:29:28 +00:00
|
|
|
|
private:
|
2012-07-23 19:02:52 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Lock file used for upgrading.
|
|
|
|
|
*/
|
2016-04-08 16:07:13 +00:00
|
|
|
|
AutoCloseFD globalLock;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2016-04-08 16:07:13 +00:00
|
|
|
|
struct State
|
|
|
|
|
{
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* The SQLite database object.
|
|
|
|
|
*/
|
2016-04-08 16:07:13 +00:00
|
|
|
|
SQLite db;
|
|
|
|
|
|
2020-12-08 05:57:31 +00:00
|
|
|
|
struct Stmts;
|
|
|
|
|
std::unique_ptr<Stmts> stmts;
|
2016-04-08 16:07:13 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* The last time we checked whether to do an auto-GC, or an
|
|
|
|
|
* auto-GC finished.
|
|
|
|
|
*/
|
2017-09-05 18:43:42 +00:00
|
|
|
|
std::chrono::time_point<std::chrono::steady_clock> lastGCCheck;
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Whether auto-GC is running. If so, get gcFuture to wait for
|
|
|
|
|
* the GC to finish.
|
|
|
|
|
*/
|
2017-09-05 18:43:42 +00:00
|
|
|
|
bool gcRunning = false;
|
|
|
|
|
std::shared_future<void> gcFuture;
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* How much disk space was available after the previous
|
|
|
|
|
* auto-GC. If the current available disk space is below
|
|
|
|
|
* minFree but not much below availAfterGC, then there is no
|
|
|
|
|
* point in starting a new GC.
|
|
|
|
|
*/
|
2017-09-05 18:43:42 +00:00
|
|
|
|
uint64_t availAfterGC = std::numeric_limits<uint64_t>::max();
|
2018-04-13 13:42:35 +00:00
|
|
|
|
|
|
|
|
|
std::unique_ptr<PublicKeys> publicKeys;
|
2016-04-08 16:07:13 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-11-03 11:52:57 +00:00
|
|
|
|
Sync<State> _state;
|
2016-04-08 16:07:13 +00:00
|
|
|
|
|
2016-06-02 14:51:43 +00:00
|
|
|
|
public:
|
|
|
|
|
|
2016-06-02 11:33:49 +00:00
|
|
|
|
const Path dbDir;
|
2016-04-08 16:07:13 +00:00
|
|
|
|
const Path linksDir;
|
|
|
|
|
const Path reservedPath;
|
|
|
|
|
const Path schemaPath;
|
2017-09-05 18:39:57 +00:00
|
|
|
|
const Path tempRootsDir;
|
|
|
|
|
const Path fnTempRoots;
|
2016-02-24 16:33:53 +00:00
|
|
|
|
|
2016-06-02 14:51:43 +00:00
|
|
|
|
private:
|
|
|
|
|
|
2018-04-13 13:42:35 +00:00
|
|
|
|
const PublicKeys & getPublicKeys();
|
2016-05-30 11:55:09 +00:00
|
|
|
|
|
2024-04-22 17:32:21 +00:00
|
|
|
|
protected:
|
2018-02-12 21:48:55 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Initialise the local store, upgrading the schema if
|
|
|
|
|
* necessary.
|
2024-04-22 17:32:21 +00:00
|
|
|
|
* Protected so that users don't accidentally create a LocalStore
|
|
|
|
|
* instead of a platform's subclass.
|
2023-04-07 13:55:28 +00:00
|
|
|
|
*/
|
2016-06-01 12:49:12 +00:00
|
|
|
|
LocalStore(const Params & params);
|
2023-03-23 14:23:13 +00:00
|
|
|
|
LocalStore(std::string scheme, std::string path, const Params & params);
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2024-04-22 17:32:21 +00:00
|
|
|
|
public:
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Hack for build-remote.cc.
|
|
|
|
|
*/
|
|
|
|
|
PathSet locksHeld;
|
|
|
|
|
|
|
|
|
|
virtual ~LocalStore();
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2023-03-23 14:23:13 +00:00
|
|
|
|
static std::set<std::string> uriSchemes()
|
|
|
|
|
{ return {}; }
|
|
|
|
|
|
2024-04-22 17:32:21 +00:00
|
|
|
|
/**
|
|
|
|
|
* Create a LocalStore, possibly a platform-specific subclass
|
|
|
|
|
*/
|
|
|
|
|
static std::shared_ptr<LocalStore> makeLocalStore(const Params & params);
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Implementations of abstract store API methods.
|
|
|
|
|
*/
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2016-04-29 14:26:16 +00:00
|
|
|
|
std::string getUri() override;
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
bool isValidPathUncached(const StorePath & path) override;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
StorePathSet queryValidPaths(const StorePathSet & paths,
|
2017-06-28 16:11:01 +00:00
|
|
|
|
SubstituteFlag maybeSubstitute = NoSubstitute) override;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
StorePathSet queryAllValidPaths() override;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2024-04-27 19:24:36 +00:00
|
|
|
|
std::shared_ptr<const ValidPathInfo> queryPathInfoUncached(const StorePath & path) override;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
void queryReferrers(const StorePath & path, StorePathSet & referrers) override;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
StorePathSet queryValidDerivers(const StorePath & path) override;
|
2010-02-22 12:44:36 +00:00
|
|
|
|
|
2023-07-19 18:52:35 +00:00
|
|
|
|
std::map<std::string, std::optional<StorePath>> queryStaticPartialDerivationOutputMap(const StorePath & path) override;
|
2011-11-06 06:28:20 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
std::optional<StorePath> queryPathFromHashPart(const std::string & hashPart) override;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
StorePathSet querySubstitutablePaths(const StorePathSet & paths) override;
|
2008-08-02 12:54:35 +00:00
|
|
|
|
|
2021-03-08 14:07:33 +00:00
|
|
|
|
bool pathInfoIsUntrusted(const ValidPathInfo &) override;
|
2021-03-08 10:56:33 +00:00
|
|
|
|
bool realisationIsUntrusted(const Realisation & ) override;
|
2021-01-15 16:37:41 +00:00
|
|
|
|
|
2018-03-16 19:22:34 +00:00
|
|
|
|
void addToStore(const ValidPathInfo & info, Source & source,
|
2020-07-13 15:37:44 +00:00
|
|
|
|
RepairFlag repair, CheckSigsFlag checkSigs) override;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2022-02-15 14:08:06 +00:00
|
|
|
|
StorePath addToStoreFromDump(Source & dump, std::string_view name,
|
2021-11-09 09:24:49 +00:00
|
|
|
|
FileIngestionMethod method, HashType hashAlgo, RepairFlag repair, const StorePathSet & references) override;
|
2008-12-03 18:05:14 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
StorePath addTextToStore(
|
|
|
|
|
std::string_view name,
|
|
|
|
|
std::string_view s,
|
|
|
|
|
const StorePathSet & references,
|
|
|
|
|
RepairFlag repair) override;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
void addTempRoot(const StorePath & path) override;
|
2006-12-02 16:41:36 +00:00
|
|
|
|
|
2023-01-03 13:51:23 +00:00
|
|
|
|
private:
|
|
|
|
|
|
|
|
|
|
void createTempRootsFile();
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* The file to which we write our temporary roots.
|
|
|
|
|
*/
|
2023-01-03 13:51:23 +00:00
|
|
|
|
Sync<AutoCloseFD> _fdTempRoots;
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* The global GC lock.
|
|
|
|
|
*/
|
2023-01-03 14:15:14 +00:00
|
|
|
|
Sync<AutoCloseFD> _fdGCLock;
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Connection to the garbage collector.
|
|
|
|
|
*/
|
2023-01-03 14:15:14 +00:00
|
|
|
|
Sync<AutoCloseFD> _fdRootsSocket;
|
|
|
|
|
|
2023-01-03 13:51:23 +00:00
|
|
|
|
public:
|
|
|
|
|
|
2023-03-23 14:06:45 +00:00
|
|
|
|
/**
|
|
|
|
|
* Implementation of IndirectRootStore::addIndirectRoot().
|
|
|
|
|
*
|
|
|
|
|
* The weak reference merely is a symlink to `path' from
|
|
|
|
|
* /nix/var/nix/gcroots/auto/<hash of `path'>.
|
|
|
|
|
*/
|
2015-09-17 23:22:06 +00:00
|
|
|
|
void addIndirectRoot(const Path & path) override;
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2016-06-02 11:33:49 +00:00
|
|
|
|
private:
|
|
|
|
|
|
2021-08-16 18:03:32 +00:00
|
|
|
|
void findTempRoots(Roots & roots, bool censor);
|
2016-06-02 11:33:49 +00:00
|
|
|
|
|
2021-08-19 20:43:43 +00:00
|
|
|
|
AutoCloseFD openGCLock();
|
2016-06-02 11:33:49 +00:00
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
2019-03-14 12:50:07 +00:00
|
|
|
|
Roots findRoots(bool censor) override;
|
2006-12-05 02:18:46 +00:00
|
|
|
|
|
2015-09-17 23:22:06 +00:00
|
|
|
|
void collectGarbage(const GCOptions & options, GCResults & results) override;
|
2007-10-09 22:14:27 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Optimise the disk space usage of the Nix store by hard-linking
|
|
|
|
|
* files with the same contents.
|
|
|
|
|
*/
|
2012-07-23 16:08:34 +00:00
|
|
|
|
void optimiseStore(OptimiseStats & stats);
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2015-09-17 23:22:06 +00:00
|
|
|
|
void optimiseStore() override;
|
2014-09-01 20:21:42 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Optimise a single store path. Optionally, test the encountered
|
|
|
|
|
* symlinks for corruption.
|
|
|
|
|
*/
|
2022-01-11 12:34:57 +00:00
|
|
|
|
void optimisePath(const Path & path, RepairFlag repair);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2017-06-28 16:11:01 +00:00
|
|
|
|
bool verifyStore(bool checkContents, RepairFlag repair) override;
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Register the validity of a path, i.e., that `path` exists, that
|
|
|
|
|
* the paths referenced by it exists, and in the case of an output
|
|
|
|
|
* path of a derivation, that it has been produced by a successful
|
|
|
|
|
* execution of the derivation (or something equivalent). Also
|
|
|
|
|
* register the hash of the file system contents of the path. The
|
|
|
|
|
* hash must be a SHA-256 hash.
|
|
|
|
|
*/
|
2010-11-16 17:11:46 +00:00
|
|
|
|
void registerValidPath(const ValidPathInfo & info);
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2008-06-09 13:52:45 +00:00
|
|
|
|
void registerValidPaths(const ValidPathInfos & infos);
|
|
|
|
|
|
2018-08-30 21:28:47 +00:00
|
|
|
|
unsigned int getProtocol() override;
|
|
|
|
|
|
2022-12-26 20:21:08 +00:00
|
|
|
|
std::optional<TrustedFlag> isTrustedClient() override;
|
|
|
|
|
|
2012-09-13 18:33:41 +00:00
|
|
|
|
void vacuumDB();
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
void addSignatures(const StorePath & storePath, const StringSet & sigs) override;
|
2016-04-05 13:30:22 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* If free disk space in /nix/store if below minFree, delete
|
|
|
|
|
* garbage until it exceeds maxFree.
|
|
|
|
|
*/
|
2017-09-05 18:43:42 +00:00
|
|
|
|
void autoGC(bool sync = true);
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Register the store path 'output' as the output named 'outputName' of
|
|
|
|
|
* derivation 'deriver'.
|
|
|
|
|
*/
|
2020-10-20 13:14:02 +00:00
|
|
|
|
void registerDrvOutput(const Realisation & info) override;
|
2021-03-08 15:43:11 +00:00
|
|
|
|
void registerDrvOutput(const Realisation & info, CheckSigsFlag checkSigs) override;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
void cacheDrvOutputMapping(
|
|
|
|
|
State & state,
|
|
|
|
|
const uint64_t deriver,
|
|
|
|
|
const std::string & outputName,
|
|
|
|
|
const StorePath & output);
|
2020-10-08 15:36:51 +00:00
|
|
|
|
|
2021-05-19 14:19:46 +00:00
|
|
|
|
std::optional<const Realisation> queryRealisation_(State & state, const DrvOutput & id);
|
|
|
|
|
std::optional<std::pair<int64_t, Realisation>> queryRealisationCore_(State & state, const DrvOutput & id);
|
2024-04-27 21:44:12 +00:00
|
|
|
|
std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput&) override;
|
2020-10-08 15:36:51 +00:00
|
|
|
|
|
2022-01-25 20:14:27 +00:00
|
|
|
|
std::optional<std::string> getVersion() override;
|
2020-10-08 15:36:51 +00:00
|
|
|
|
|
2016-01-31 09:19:14 +00:00
|
|
|
|
private:
|
|
|
|
|
|
2023-06-20 09:34:09 +00:00
|
|
|
|
/**
|
|
|
|
|
* Retrieve the current version of the database schema.
|
|
|
|
|
* If the database does not exist yet, the version returned will be 0.
|
|
|
|
|
*/
|
2016-04-08 16:07:13 +00:00
|
|
|
|
int getSchema();
|
2010-02-24 15:07:23 +00:00
|
|
|
|
|
2016-04-08 16:07:13 +00:00
|
|
|
|
void openDB(State & state, bool create);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2016-04-08 16:07:13 +00:00
|
|
|
|
void makeStoreWritable();
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
uint64_t queryValidPathId(State & state, const StorePath & path);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2016-04-08 16:07:13 +00:00
|
|
|
|
uint64_t addValidPath(State & state, const ValidPathInfo & info, bool checkOutputs = true);
|
2008-06-09 13:52:45 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
void invalidatePath(State & state, const StorePath & path);
|
2010-02-18 15:11:08 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Delete a path from the Nix store.
|
|
|
|
|
*/
|
2019-12-05 18:11:09 +00:00
|
|
|
|
void invalidatePathChecked(const StorePath & path);
|
2012-07-30 23:55:41 +00:00
|
|
|
|
|
2023-07-31 15:13:38 +00:00
|
|
|
|
void verifyPath(const StorePath & path, const StorePathSet & store,
|
2023-07-28 09:11:45 +00:00
|
|
|
|
StorePathSet & done, StorePathSet & validPaths, RepairFlag repair, bool & errors);
|
2010-08-31 11:47:31 +00:00
|
|
|
|
|
2021-01-05 10:47:29 +00:00
|
|
|
|
std::shared_ptr<const ValidPathInfo> queryPathInfoInternal(State & state, const StorePath & path);
|
|
|
|
|
|
2016-04-08 16:07:13 +00:00
|
|
|
|
void updatePathInfo(State & state, const ValidPathInfo & info);
|
2010-12-06 15:29:38 +00:00
|
|
|
|
|
2010-02-18 13:16:59 +00:00
|
|
|
|
void upgradeStore6();
|
2013-01-03 11:59:23 +00:00
|
|
|
|
void upgradeStore7();
|
2010-02-18 15:11:08 +00:00
|
|
|
|
PathSet queryValidPathsOld();
|
|
|
|
|
ValidPathInfo queryPathInfoOld(const Path & path);
|
2008-06-09 13:52:45 +00:00
|
|
|
|
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
void findRoots(const Path & path, unsigned char type, Roots & roots);
|
|
|
|
|
|
2019-03-14 12:50:07 +00:00
|
|
|
|
void findRootsNoTemp(Roots & roots, bool censor);
|
2017-09-14 12:38:36 +00:00
|
|
|
|
|
2024-04-22 17:32:21 +00:00
|
|
|
|
/**
|
|
|
|
|
* Find possible garbage collector roots in a platform-specific manner,
|
|
|
|
|
* e.g. by looking in `/proc` or using `lsof`
|
|
|
|
|
*/
|
|
|
|
|
virtual void findPlatformRoots(UncheckedRoots & unchecked);
|
|
|
|
|
|
2019-03-14 12:50:07 +00:00
|
|
|
|
void findRuntimeRoots(Roots & roots, bool censor);
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
|
2022-09-06 22:48:00 +00:00
|
|
|
|
std::pair<Path, AutoCloseFD> createTempDirInStore();
|
2011-07-20 18:10:47 +00:00
|
|
|
|
|
2014-05-26 15:53:17 +00:00
|
|
|
|
typedef std::unordered_set<ino_t> InodeHash;
|
2014-05-13 21:10:06 +00:00
|
|
|
|
|
2014-05-14 20:52:10 +00:00
|
|
|
|
InodeHash loadInodeHash();
|
2014-05-15 09:33:46 +00:00
|
|
|
|
Strings readDirectoryIgnoringInodes(const Path & path, const InodeHash & inodeHash);
|
2022-01-11 12:34:57 +00:00
|
|
|
|
void optimisePath_(Activity * act, OptimiseStats & stats, const Path & path, InodeHash & inodeHash, RepairFlag repair);
|
2013-10-16 13:58:20 +00:00
|
|
|
|
|
|
|
|
|
// Internal versions that are not wrapped in retry_sqlite.
|
2019-12-05 18:11:09 +00:00
|
|
|
|
bool isValidPath_(State & state, const StorePath & path);
|
|
|
|
|
void queryReferrers(State & state, const StorePath & path, StorePathSet & referrers);
|
2016-04-07 12:14:06 +00:00
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* Add signatures to a ValidPathInfo or Realisation using the secret keys
|
|
|
|
|
* specified by the ‘secret-key-files’ option.
|
|
|
|
|
*/
|
2016-04-07 12:14:06 +00:00
|
|
|
|
void signPathInfo(ValidPathInfo & info);
|
2021-03-08 10:56:33 +00:00
|
|
|
|
void signRealisation(Realisation &);
|
2020-08-07 19:09:26 +00:00
|
|
|
|
|
2021-05-27 11:25:25 +00:00
|
|
|
|
// XXX: Make a generic `Store` method
|
2023-07-05 22:53:44 +00:00
|
|
|
|
ContentAddress hashCAPath(
|
|
|
|
|
const ContentAddressMethod & method,
|
2021-05-27 11:25:25 +00:00
|
|
|
|
const HashType & hashType,
|
|
|
|
|
const StorePath & path);
|
|
|
|
|
|
2023-07-05 22:53:44 +00:00
|
|
|
|
ContentAddress hashCAPath(
|
|
|
|
|
const ContentAddressMethod & method,
|
2021-05-27 11:25:25 +00:00
|
|
|
|
const HashType & hashType,
|
|
|
|
|
const Path & path,
|
|
|
|
|
const std::string_view pathHash
|
|
|
|
|
);
|
|
|
|
|
|
2022-01-17 18:45:21 +00:00
|
|
|
|
void addBuildLog(const StorePath & drvPath, std::string_view log) override;
|
|
|
|
|
|
2021-02-26 15:20:33 +00:00
|
|
|
|
friend struct LocalDerivationGoal;
|
2020-11-09 12:47:06 +00:00
|
|
|
|
friend struct PathSubstitutionGoal;
|
2020-12-01 13:57:56 +00:00
|
|
|
|
friend struct SubstitutionGoal;
|
2020-11-09 12:47:06 +00:00
|
|
|
|
friend struct DerivationGoal;
|
2008-06-09 13:52:45 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2013-06-13 15:29:56 +00:00
|
|
|
|
typedef std::pair<dev_t, ino_t> Inode;
|
2022-02-21 15:28:23 +00:00
|
|
|
|
typedef std::set<Inode> InodesSeen;
|
2013-06-13 15:29:56 +00:00
|
|
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
|
/**
|
|
|
|
|
* "Fix", or canonicalise, the meta-data of the files in a store path
|
|
|
|
|
* after it has been built. In particular:
|
|
|
|
|
*
|
|
|
|
|
* - the last modification date on each file is set to 1 (i.e.,
|
|
|
|
|
* 00:00:01 1/1/1970 UTC)
|
|
|
|
|
*
|
|
|
|
|
* - the permissions are set of 444 or 555 (i.e., read-only with or
|
|
|
|
|
* without execute permission; setuid bits etc. are cleared)
|
|
|
|
|
*
|
|
|
|
|
* - the owner and group are set to the Nix user and group, if we're
|
|
|
|
|
* running as root.
|
|
|
|
|
*
|
|
|
|
|
* If uidRange is not empty, this function will throw an error if it
|
|
|
|
|
* encounters files owned by a user outside of the closed interval
|
|
|
|
|
* [uidRange->first, uidRange->second].
|
|
|
|
|
*/
|
2020-05-14 11:52:41 +00:00
|
|
|
|
void canonicalisePathMetaData(
|
|
|
|
|
const Path & path,
|
|
|
|
|
std::optional<std::pair<uid_t, uid_t>> uidRange,
|
|
|
|
|
InodesSeen & inodesSeen);
|
|
|
|
|
void canonicalisePathMetaData(
|
|
|
|
|
const Path & path,
|
|
|
|
|
std::optional<std::pair<uid_t, uid_t>> uidRange);
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2013-03-08 00:24:59 +00:00
|
|
|
|
void canonicaliseTimestampAndPermissions(const Path & path);
|
2006-11-30 17:43:04 +00:00
|
|
|
|
|
2007-01-14 16:24:49 +00:00
|
|
|
|
MakeError(PathInUse, Error);
|
|
|
|
|
|
2006-11-30 17:43:04 +00:00
|
|
|
|
}
|