Nix 2.26.3
Nix, the purely functional package manager; unstable internal interfaces
 
Loading...
Searching...
No Matches
nix::LocalStore Class Reference
Inheritance diagram for nix::LocalStore:
nix::LocalStoreConfig nix::IndirectRootStore nix::GcStore nix::LocalFSStoreConfig nix::LocalFSStore nix::Store nix::StoreConfig nix::LocalFSStoreConfig nix::Store nix::GcStore nix::LogStore nix::StoreConfig nix::StoreDirConfig nix::StoreConfig nix::StoreConfig nix::Store nix::Store nix::StoreDirConfig nix::Config nix::StoreConfig nix::StoreConfig nix::StoreDirConfig nix::StoreDirConfig nix::Config nix::LocalOverlayStore

Classes

struct  VerificationResult
 

Public Member Functions

 LocalStore (const Params &params)
 
 LocalStore (std::string_view scheme, PathView path, const Params &params)
 
std::string getUri () override
 
bool isValidPathUncached (const StorePath &path) override
 
StorePathSet queryValidPaths (const StorePathSet &paths, SubstituteFlag maybeSubstitute=NoSubstitute) override
 
StorePathSet queryAllValidPaths () override
 
void queryPathInfoUncached (const StorePath &path, Callback< std::shared_ptr< const ValidPathInfo > > callback) noexcept override
 
void queryReferrers (const StorePath &path, StorePathSet &referrers) override
 
StorePathSet queryValidDerivers (const StorePath &path) override
 
std::map< std::string, std::optional< StorePath > > queryStaticPartialDerivationOutputMap (const StorePath &path) override
 
std::optional< StorePathqueryPathFromHashPart (const std::string &hashPart) override
 
StorePathSet querySubstitutablePaths (const StorePathSet &paths) override
 
bool pathInfoIsUntrusted (const ValidPathInfo &) override
 
bool realisationIsUntrusted (const Realisation &) override
 
void addToStore (const ValidPathInfo &info, Source &source, RepairFlag repair, CheckSigsFlag checkSigs) override
 
StorePath addToStoreFromDump (Source &dump, std::string_view name, FileSerialisationMethod dumpMethod, ContentAddressMethod hashMethod, HashAlgorithm hashAlgo, const StorePathSet &references, RepairFlag repair) override
 
void addTempRoot (const StorePath &path) override
 
void addIndirectRoot (const Path &path) override
 
Roots findRoots (bool censor) override
 
void collectGarbage (const GCOptions &options, GCResults &results) override
 
virtual void queryGCReferrers (const StorePath &path, StorePathSet &referrers)
 
virtual void deleteStorePath (const Path &path, uint64_t &bytesFreed)
 
void optimiseStore (OptimiseStats &stats)
 
void optimiseStore () override
 
void optimisePath (const Path &path, RepairFlag repair)
 
bool verifyStore (bool checkContents, RepairFlag repair) override
 
void registerValidPath (const ValidPathInfo &info)
 
virtual void registerValidPaths (const ValidPathInfos &infos)
 
unsigned int getProtocol () override
 
std::optional< TrustedFlag > isTrustedClient () override
 
void vacuumDB ()
 
void addSignatures (const StorePath &storePath, const StringSet &sigs) override
 
void autoGC (bool sync=true)
 
void registerDrvOutput (const Realisation &info) override
 
void registerDrvOutput (const Realisation &info, CheckSigsFlag checkSigs) override
 
void cacheDrvOutputMapping (State &state, const uint64_t deriver, const std::string &outputName, const StorePath &output)
 
std::optional< const RealisationqueryRealisation_ (State &state, const DrvOutput &id)
 
std::optional< std::pair< int64_t, Realisation > > queryRealisationCore_ (State &state, const DrvOutput &id)
 
void queryRealisationUncached (const DrvOutput &, Callback< std::shared_ptr< const Realisation > > callback) noexcept override
 
std::optional< std::string > getVersion () override
 
- Public Member Functions inherited from nix::LocalStoreConfig
 LocalStoreConfig (std::string_view scheme, std::string_view authority, const Params &params)
 
const std::string name () override
 
std::string doc () override
 
 LocalFSStoreConfig (PathView path, const Params &params)
 
- Public Member Functions inherited from nix::LocalFSStoreConfig
 LocalFSStoreConfig (PathView path, const Params &params)
 
 StoreConfig ()=delete
 
- Public Member Functions inherited from nix::StoreConfig
virtual std::optional< ExperimentalFeatureexperimentalFeature () const
 
 StoreDirConfig ()=delete
 
- Public Member Functions inherited from nix::StoreDirConfig
StorePath parseStorePath (std::string_view path) const
 
std::optional< StorePathmaybeParseStorePath (std::string_view path) const
 
std::string printStorePath (const StorePath &path) const
 
StorePathSet parseStorePathSet (const PathSet &paths) const
 
PathSet printStorePathSet (const StorePathSet &path) const
 
std::string showPaths (const StorePathSet &paths)
 
bool isInStore (PathView path) const
 
bool isStorePath (std::string_view path) const
 
std::pair< StorePath, PathtoStorePath (PathView path) const
 
StorePath makeStorePath (std::string_view type, std::string_view hash, std::string_view name) const
 
StorePath makeStorePath (std::string_view type, const Hash &hash, std::string_view name) const
 
StorePath makeOutputPath (std::string_view id, const Hash &hash, std::string_view name) const
 
StorePath makeFixedOutputPath (std::string_view name, const FixedOutputInfo &info) const
 
StorePath makeFixedOutputPathFromCA (std::string_view name, const ContentAddressWithReferences &ca) const
 
std::pair< StorePath, HashcomputeStorePath (std::string_view name, const SourcePath &path, ContentAddressMethod method=FileIngestionMethod::NixArchive, HashAlgorithm hashAlgo=HashAlgorithm::SHA256, const StorePathSet &references={}, PathFilter &filter=defaultPathFilter) const
 
 Config (StringMap initials={})
 
- Public Member Functions inherited from nix::Config
 Config (StringMap initials={})
 
bool set (const std::string &name, const std::string &value) override
 
void addSetting (AbstractSetting *setting)
 
void getSettings (std::map< std::string, SettingInfo > &res, bool overriddenOnly=false) override
 
void resetOverridden () override
 
nlohmann::json toJSON () override
 
std::string toKeyValue () override
 
void convertToArgs (Args &args, const std::string &category) override
 
- Public Member Functions inherited from nix::AbstractConfig
void applyConfig (const std::string &contents, const std::string &path="<unknown>")
 
void warnUnknownSettings ()
 
void reapplyUnknownSettings ()
 
- Public Member Functions inherited from nix::IndirectRootStore
Path addPermRoot (const StorePath &storePath, const Path &gcRoot) override final
 
- Public Member Functions inherited from nix::LocalFSStore
 LocalFSStore (const Params &params)
 
void narFromPath (const StorePath &path, Sink &sink) override
 
ref< SourceAccessorgetFSAccessor (bool requireValidPath=true) override
 
virtual Path getRealStoreDir ()
 
Path toRealPath (const Path &storePath) override
 
std::optional< std::string > getBuildLogExact (const StorePath &path) override
 
- Public Member Functions inherited from nix::Store
virtual void init ()
 
Path followLinksToStore (std::string_view path) const
 
StorePath followLinksToStorePath (std::string_view path) const
 
bool isValidPath (const StorePath &path)
 
void substitutePaths (const StorePathSet &paths)
 
ref< const ValidPathInfoqueryPathInfo (const StorePath &path)
 
void queryPathInfo (const StorePath &path, Callback< ref< const ValidPathInfo > > callback) noexcept
 
std::optional< std::shared_ptr< const ValidPathInfo > > queryPathInfoFromClientCache (const StorePath &path)
 
std::shared_ptr< const RealisationqueryRealisation (const DrvOutput &)
 
void queryRealisation (const DrvOutput &, Callback< std::shared_ptr< const Realisation > > callback) noexcept
 
virtual StorePathSet queryDerivationOutputs (const StorePath &path)
 
virtual std::map< std::string, std::optional< StorePath > > queryPartialDerivationOutputMap (const StorePath &path, Store *evalStore=nullptr)
 
OutputPathMap queryDerivationOutputMap (const StorePath &path, Store *evalStore=nullptr)
 
virtual void querySubstitutablePathInfos (const StorePathCAMap &paths, SubstitutablePathInfos &infos)
 
virtual void addMultipleToStore (Source &source, RepairFlag repair=NoRepair, CheckSigsFlag checkSigs=CheckSigs)
 
virtual void addMultipleToStore (PathsSource &&pathsToCopy, Activity &act, RepairFlag repair=NoRepair, CheckSigsFlag checkSigs=CheckSigs)
 
virtual StorePath addToStore (std::string_view name, const SourcePath &path, ContentAddressMethod method=ContentAddressMethod::Raw::NixArchive, HashAlgorithm hashAlgo=HashAlgorithm::SHA256, const StorePathSet &references=StorePathSet(), PathFilter &filter=defaultPathFilter, RepairFlag repair=NoRepair)
 
ValidPathInfo addToStoreSlow (std::string_view name, const SourcePath &path, ContentAddressMethod method=ContentAddressMethod::Raw::NixArchive, HashAlgorithm hashAlgo=HashAlgorithm::SHA256, const StorePathSet &references=StorePathSet(), std::optional< Hash > expectedCAHash={})
 
virtual void buildPaths (const std::vector< DerivedPath > &paths, BuildMode buildMode=bmNormal, std::shared_ptr< Store > evalStore=nullptr)
 
virtual std::vector< KeyedBuildResultbuildPathsWithResults (const std::vector< DerivedPath > &paths, BuildMode buildMode=bmNormal, std::shared_ptr< Store > evalStore=nullptr)
 
virtual BuildResult buildDerivation (const StorePath &drvPath, const BasicDerivation &drv, BuildMode buildMode=bmNormal)
 
virtual void ensurePath (const StorePath &path)
 
std::string makeValidityRegistration (const StorePathSet &paths, bool showDerivers, bool showHash)
 
virtual void repairPath (const StorePath &path)
 
Derivation derivationFromPath (const StorePath &drvPath)
 
Derivation readDerivation (const StorePath &drvPath)
 
Derivation readInvalidDerivation (const StorePath &drvPath)
 
virtual void computeFSClosure (const StorePathSet &paths, StorePathSet &out, bool flipDirection=false, bool includeOutputs=false, bool includeDerivers=false)
 
void computeFSClosure (const StorePath &path, StorePathSet &out, bool flipDirection=false, bool includeOutputs=false, bool includeDerivers=false)
 
virtual void queryMissing (const std::vector< DerivedPath > &targets, StorePathSet &willBuild, StorePathSet &willSubstitute, StorePathSet &unknown, uint64_t &downloadSize, uint64_t &narSize)
 
StorePaths topoSortPaths (const StorePathSet &paths)
 
void exportPaths (const StorePathSet &paths, Sink &sink)
 
void exportPath (const StorePath &path, Sink &sink)
 
StorePaths importPaths (Source &source, CheckSigsFlag checkSigs=CheckSigs)
 
const StatsgetStats ()
 
StorePathSet exportReferences (const StorePathSet &storePaths, const StorePathSet &inputPaths)
 
std::optional< StorePathgetBuildDerivationPath (const StorePath &)
 
void clearPathInfoCache ()
 
virtual void connect ()
 
Path toRealPath (const StorePath &storePath)
 
virtual void setOptions ()
 
- Public Member Functions inherited from nix::LogStore
std::optional< std::string > getBuildLog (const StorePath &path)
 

Public Attributes

const Path dbDir
 
const Path linksDir
 
const Path reservedPath
 
const Path schemaPath
 
const Path tempRootsDir
 
const Path fnTempRoots
 
PathSet locksHeld
 
- Public Attributes inherited from nix::LocalStoreConfig
Setting< bool > requireSigs
 
Setting< bool > readOnly
 
- Public Attributes inherited from nix::LocalFSStoreConfig
const OptionalPathSetting rootDir
 
const PathSetting stateDir
 
const PathSetting logDir
 
const PathSetting realStoreDir
 
- Public Attributes inherited from nix::StoreConfig
const Setting< intpathInfoCacheSize
 
const Setting< bool > isTrusted
 
Setting< intpriority
 
Setting< bool > wantMassQuery
 
Setting< StringSet > systemFeatures
 
- Public Attributes inherited from nix::StoreDirConfig
const PathSetting storeDir_
 
const Path storeDir = storeDir_
 

Protected Member Functions

virtual VerificationResult verifyAllValidPaths (RepairFlag repair)
 
void verifyPath (const StorePath &path, std::function< bool(const StorePath &)> existsInStoreDir, StorePathSet &done, StorePathSet &validPaths, RepairFlag repair, bool &errors)
 
- Protected Member Functions inherited from nix::AbstractConfig
 AbstractConfig (StringMap initials={})
 
- Protected Member Functions inherited from nix::IndirectRootStore
void makeSymlink (const Path &link, const Path &target)
 
- Protected Member Functions inherited from nix::Store
 Store (const Params &params)
 
void unsupported (const std::string &op)
 

Friends

struct LocalDerivationGoal
 
struct PathSubstitutionGoal
 
struct SubstitutionGoal
 
struct DerivationGoal
 

Additional Inherited Members

- Public Types inherited from nix::StoreConfig
using Params = StoreReference::Params
 
- Public Types inherited from nix::Config
using Settings = std::map<std::string, SettingData>
 
- Public Types inherited from nix::Store
using PathsSource = std::vector<std::pair<ValidPathInfo, std::unique_ptr<Source>>>
 
- Static Public Member Functions inherited from nix::LocalStoreConfig
static std::set< std::string > uriSchemes ()
 
- Static Public Member Functions inherited from nix::StoreConfig
static StringSet getDefaultSystemFeatures ()
 
- Static Public Member Functions inherited from nix::LogStore
static LogStorerequire (Store &store)
 
- Static Public Attributes inherited from nix::IndirectRootStore
static std::string operationName = "Indirect GC roots registration"
 
- Static Public Attributes inherited from nix::LocalFSStore
static std::string operationName = "Local Filesystem Store"
 
static const std::string drvsLogDir = "drvs"
 
- Static Public Attributes inherited from nix::Store
static constexpr const charMissingName = "x"
 
- Static Public Attributes inherited from nix::GcStore
static std::string operationName = "Garbage collection"
 
- Static Public Attributes inherited from nix::LogStore
static std::string operationName = "Build log storage and retrieval"
 
- Protected Attributes inherited from nix::AbstractConfig
StringMap unknownSettings
 
- Protected Attributes inherited from nix::Store
SharedSync< Statestate
 
std::shared_ptr< NarInfoDiskCachediskCache
 
Stats stats
 

Constructor & Destructor Documentation

◆ LocalStore()

nix::LocalStore::LocalStore ( const Params & params)

Initialise the local store, upgrading the schema if necessary.

Member Function Documentation

◆ addIndirectRoot()

void nix::LocalStore::addIndirectRoot ( const Path & path)
overridevirtual

Implementation of IndirectRootStore::addIndirectRoot().

The weak reference merely is a symlink to ‘path’ from /nix/var/nix/gcroots/auto/<hash of `path'>.

Implements nix::IndirectRootStore.

◆ addSignatures()

void nix::LocalStore::addSignatures ( const StorePath & storePath,
const StringSet & sigs )
overridevirtual

Add signatures to the specified store path. The signatures are not verified.

Reimplemented from nix::Store.

◆ addTempRoot()

void nix::LocalStore::addTempRoot ( const StorePath & path)
overridevirtual

Add a store path as a temporary root of the garbage collector. The root disappears as soon as we exit.

Reimplemented from nix::Store.

◆ addToStore()

void nix::LocalStore::addToStore ( const ValidPathInfo & info,
Source & narSource,
RepairFlag repair,
CheckSigsFlag checkSigs )
overridevirtual

Import a path into the store.

Implements nix::Store.

◆ addToStoreFromDump()

StorePath nix::LocalStore::addToStoreFromDump ( Source & dump,
std::string_view name,
FileSerialisationMethod dumpMethod,
ContentAddressMethod hashMethod,
HashAlgorithm hashAlgo,
const StorePathSet & references,
RepairFlag repair )
overridevirtual

Like addToStore(), but the contents of the path are contained in dump, which is either a NAR serialisation (if recursive == true) or simply the contents of a regular file (if recursive == false).

dump may be drained.

Parameters
dumpMethodWhat serialisation format is dump, i.e. how to deserialize it. Must either match hashMethod or be FileSerialisationMethod::NixArchive.
hashMethodHow content addressing? Need not match be the same as dumpMethod.
Todo
remove?

Implements nix::Store.

◆ autoGC()

void nix::LocalStore::autoGC ( bool sync = true)

If free disk space in /nix/store if below minFree, delete garbage until it exceeds maxFree.

◆ collectGarbage()

void nix::LocalStore::collectGarbage ( const GCOptions & options,
GCResults & results )
overridevirtual

Perform a garbage collection.

Implements nix::GcStore.

◆ deleteStorePath()

void nix::LocalStore::deleteStorePath ( const Path & path,
uint64_t & bytesFreed )
virtual

Called by collectGarbage to recursively delete a path. The default implementation simply calls deletePath, but it can be overridden by stores that wish to provide their own deletion behaviour.

◆ findRoots()

Roots nix::LocalStore::findRoots ( bool censor)
overridevirtual

Find the roots of the garbage collector. Each root is a pair (link, storepath) where link is the path of the symlink outside of the Nix store that point to storePath. If censor is true, privacy-sensitive information about roots found in /proc is censored.

Implements nix::GcStore.

◆ getProtocol()

unsigned int nix::LocalStore::getProtocol ( )
overridevirtual

Get the protocol version of this store or it's connection.

Reimplemented from nix::Store.

◆ getUri()

std::string nix::LocalStore::getUri ( )
overridevirtual

Implementations of abstract store API methods.

Implements nix::Store.

◆ getVersion()

std::optional< std::string > nix::LocalStore::getVersion ( )
overridevirtual

Reimplemented from nix::Store.

◆ isTrustedClient()

std::optional< TrustedFlag > nix::LocalStore::isTrustedClient ( )
overridevirtual
Returns
/ whether store trusts us.

std::nullopt means we do not know.

Note
This is the opposite of the StoreConfig::isTrusted store setting. That is about whether we trust the store.

Implements nix::Store.

◆ isValidPathUncached()

bool nix::LocalStore::isValidPathUncached ( const StorePath & path)
overridevirtual

Reimplemented from nix::Store.

◆ optimisePath()

void nix::LocalStore::optimisePath ( const Path & path,
RepairFlag repair )

Optimise a single store path. Optionally, test the encountered symlinks for corruption.

◆ optimiseStore() [1/2]

void nix::LocalStore::optimiseStore ( )
overridevirtual

Optimise the disk space usage of the Nix store by hard-linking files with the same contents.

Reimplemented from nix::Store.

◆ optimiseStore() [2/2]

void nix::LocalStore::optimiseStore ( OptimiseStats & stats)

Optimise the disk space usage of the Nix store by hard-linking files with the same contents.

◆ pathInfoIsUntrusted()

bool nix::LocalStore::pathInfoIsUntrusted ( const ValidPathInfo & )
overridevirtual

Check whether the given valid path info is sufficiently attested, by either being signed by a trusted public key or content-addressed, in order to be included in the given store.

These same checks would be performed in addToStore, but this allows an earlier failure in the case where dependencies need to be added too, but the addToStore wouldn't fail until those dependencies are added. Also, we don't really want to add the dependencies listed in a nar info we don't trust anyyways.

Reimplemented from nix::Store.

◆ queryAllValidPaths()

StorePathSet nix::LocalStore::queryAllValidPaths ( )
overridevirtual

Query the set of all valid paths. Note that for some store backends, the name part of store paths may be replaced by x (i.e. you'll get /nix/store/<hash>-x rather than /nix/store/<hash>-<name>). Use queryPathInfo() to obtain the full store path. FIXME: should return a set of std::variant<StorePath, HashPart> to get rid of this hack.

Reimplemented from nix::Store.

◆ queryGCReferrers()

virtual void nix::LocalStore::queryGCReferrers ( const StorePath & path,
StorePathSet & referrers )
inlinevirtual

Called by collectGarbage to trace in reverse.

Using this rather than queryReferrers directly allows us to fine-tune which referrers we consider for garbage collection; some store implementations take advantage of this.

◆ queryPathFromHashPart()

std::optional< StorePath > nix::LocalStore::queryPathFromHashPart ( const std::string & hashPart)
overridevirtual

Query the full store path given the hash part of a valid store path, or empty if the path doesn't exist.

Implements nix::Store.

◆ queryPathInfoUncached()

void nix::LocalStore::queryPathInfoUncached ( const StorePath & path,
Callback< std::shared_ptr< const ValidPathInfo > > callback )
overridevirtualnoexcept

Implements nix::Store.

◆ queryRealisationUncached()

void nix::LocalStore::queryRealisationUncached ( const DrvOutput & id,
Callback< std::shared_ptr< const Realisation > > callback )
overridevirtualnoexcept

Implements nix::Store.

◆ queryReferrers()

void nix::LocalStore::queryReferrers ( const StorePath & path,
StorePathSet & referrers )
overridevirtual

Queries the set of incoming FS references for a store path. The result is not cleared.

Reimplemented from nix::Store.

◆ queryStaticPartialDerivationOutputMap()

std::map< std::string, std::optional< StorePath > > nix::LocalStore::queryStaticPartialDerivationOutputMap ( const StorePath & path)
overridevirtual

Like queryPartialDerivationOutputMap but only considers statically known output paths (i.e. those that can be gotten from the derivation itself.

Just a helper function for implementing queryPartialDerivationOutputMap.

Reimplemented from nix::Store.

◆ querySubstitutablePaths()

StorePathSet nix::LocalStore::querySubstitutablePaths ( const StorePathSet & paths)
overridevirtual

Query which of the given paths have substitutes.

Reimplemented from nix::Store.

◆ queryValidDerivers()

StorePathSet nix::LocalStore::queryValidDerivers ( const StorePath & path)
overridevirtual
Returns
all currently valid derivations that have path as an output.

(Note that the result of queryDeriver() is the derivation that was actually used to produce path, which may not exist anymore.)

Reimplemented from nix::Store.

◆ queryValidPaths()

StorePathSet nix::LocalStore::queryValidPaths ( const StorePathSet & paths,
SubstituteFlag maybeSubstitute = NoSubstitute )
overridevirtual

Query which of the given paths is valid. Optionally, try to substitute missing paths.

Reimplemented from nix::Store.

◆ realisationIsUntrusted()

bool nix::LocalStore::realisationIsUntrusted ( const Realisation & realisation)
overridevirtual

Reimplemented from nix::Store.

◆ registerDrvOutput() [1/2]

void nix::LocalStore::registerDrvOutput ( const Realisation & info)
overridevirtual

Register the store path 'output' as the output named 'outputName' of derivation 'deriver'.

Reimplemented from nix::Store.

◆ registerDrvOutput() [2/2]

void nix::LocalStore::registerDrvOutput ( const Realisation & info,
CheckSigsFlag checkSigs )
overridevirtual

Reimplemented from nix::Store.

◆ registerValidPath()

void nix::LocalStore::registerValidPath ( const ValidPathInfo & info)

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.

◆ verifyAllValidPaths()

LocalStore::VerificationResult nix::LocalStore::verifyAllValidPaths ( RepairFlag repair)
protectedvirtual

First, unconditional step of verifyStore

◆ verifyStore()

bool nix::LocalStore::verifyStore ( bool checkContents,
RepairFlag repair )
overridevirtual

Check the integrity of the Nix store.

Returns
true if errors remain.

Reimplemented from nix::Store.

Member Data Documentation

◆ locksHeld

PathSet nix::LocalStore::locksHeld

Hack for build-remote.cc.


The documentation for this class was generated from the following files: