#include <remote-store.hh>
Classes | |
struct | Connection |
struct | ConnectionHandle |
Public Member Functions | |
RemoteStore (const Params ¶ms) | |
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 |
StorePathSet | queryDerivationOutputs (const StorePath &path) override |
std::map< std::string, std::optional< StorePath > > | queryPartialDerivationOutputMap (const StorePath &path, Store *evalStore=nullptr) override |
std::optional< StorePath > | queryPathFromHashPart (const std::string &hashPart) override |
StorePathSet | querySubstitutablePaths (const StorePathSet &paths) override |
void | querySubstitutablePathInfos (const StorePathCAMap &paths, SubstitutablePathInfos &infos) override |
ref< const ValidPathInfo > | addCAToStore (Source &dump, std::string_view name, ContentAddressMethod caMethod, HashAlgorithm hashAlgo, const StorePathSet &references, RepairFlag repair) |
StorePath | addToStoreFromDump (Source &dump, std::string_view name, FileSerialisationMethod dumpMethod=FileSerialisationMethod::NixArchive, ContentAddressMethod hashMethod=FileIngestionMethod::NixArchive, HashAlgorithm hashAlgo=HashAlgorithm::SHA256, const StorePathSet &references=StorePathSet(), RepairFlag repair=NoRepair) override |
void | addToStore (const ValidPathInfo &info, Source &nar, RepairFlag repair, CheckSigsFlag checkSigs) override |
void | addMultipleToStore (Source &source, RepairFlag repair, CheckSigsFlag checkSigs) override |
void | addMultipleToStore (PathsSource &&pathsToCopy, Activity &act, RepairFlag repair, CheckSigsFlag checkSigs) override |
void | registerDrvOutput (const Realisation &info) override |
void | queryRealisationUncached (const DrvOutput &, Callback< std::shared_ptr< const Realisation > > callback) noexcept override |
void | buildPaths (const std::vector< DerivedPath > &paths, BuildMode buildMode, std::shared_ptr< Store > evalStore) override |
std::vector< KeyedBuildResult > | buildPathsWithResults (const std::vector< DerivedPath > &paths, BuildMode buildMode, std::shared_ptr< Store > evalStore) override |
BuildResult | buildDerivation (const StorePath &drvPath, const BasicDerivation &drv, BuildMode buildMode) override |
void | ensurePath (const StorePath &path) override |
void | addTempRoot (const StorePath &path) override |
Roots | findRoots (bool censor) override |
void | collectGarbage (const GCOptions &options, GCResults &results) override |
void | optimiseStore () override |
bool | verifyStore (bool checkContents, RepairFlag repair) override |
void | repairPath (const StorePath &path) override |
void | addSignatures (const StorePath &storePath, const StringSet &sigs) override |
void | queryMissing (const std::vector< DerivedPath > &targets, StorePathSet &willBuild, StorePathSet &willSubstitute, StorePathSet &unknown, uint64_t &downloadSize, uint64_t &narSize) override |
void | addBuildLog (const StorePath &drvPath, std::string_view log) override |
std::optional< std::string > | getVersion () override |
void | connect () override |
unsigned int | getProtocol () override |
std::optional< TrustedFlag > | isTrustedClient () override |
void | flushBadConnections () |
ref< Connection > | openConnectionWrapper () |
![]() | |
StoreConfig ()=delete | |
![]() | |
virtual const std::string | name ()=0 |
virtual std::string | doc () |
virtual std::optional< ExperimentalFeature > | experimentalFeature () const |
StoreDirConfig ()=delete | |
![]() | |
StorePath | parseStorePath (std::string_view path) const |
std::optional< StorePath > | maybeParseStorePath (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, Path > | toStorePath (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, Hash > | computeStorePath (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={}) | |
![]() | |
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 |
![]() | |
void | applyConfig (const std::string &contents, const std::string &path="<unknown>") |
void | warnUnknownSettings () |
void | reapplyUnknownSettings () |
![]() | |
virtual void | init () |
virtual std::string | getUri ()=0 |
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 ValidPathInfo > | queryPathInfo (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 Realisation > | queryRealisation (const DrvOutput &) |
void | queryRealisation (const DrvOutput &, Callback< std::shared_ptr< const Realisation > > callback) noexcept |
virtual bool | pathInfoIsUntrusted (const ValidPathInfo &) |
virtual bool | realisationIsUntrusted (const Realisation &) |
virtual std::map< std::string, std::optional< StorePath > > | queryStaticPartialDerivationOutputMap (const StorePath &path) |
OutputPathMap | queryDerivationOutputMap (const StorePath &path, Store *evalStore=nullptr) |
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 | registerDrvOutput (const Realisation &output, CheckSigsFlag checkSigs) |
std::string | makeValidityRegistration (const StorePathSet &paths, bool showDerivers, bool showHash) |
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) |
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 Stats & | getStats () |
StorePathSet | exportReferences (const StorePathSet &storePaths, const StorePathSet &inputPaths) |
std::optional< StorePath > | getBuildDerivationPath (const StorePath &) |
void | clearPathInfoCache () |
virtual Path | toRealPath (const Path &storePath) |
Path | toRealPath (const StorePath &storePath) |
![]() | |
std::optional< std::string > | getBuildLog (const StorePath &path) |
virtual std::optional< std::string > | getBuildLogExact (const StorePath &path)=0 |
Protected Member Functions | |
virtual ref< Connection > | openConnection ()=0 |
void | initConnection (Connection &conn) |
virtual void | setOptions (Connection &conn) |
void | setOptions () override |
ConnectionHandle | getConnection () |
virtual ref< SourceAccessor > | getFSAccessor (bool requireValidPath=true) override |
virtual void | narFromPath (const StorePath &path, Sink &sink) override |
![]() | |
AbstractConfig (StringMap initials={}) | |
![]() | |
Store (const Params ¶ms) | |
void | unsupported (const std::string &op) |
Protected Attributes | |
ref< Pool< Connection > > | connections |
![]() | |
StringMap | unknownSettings |
![]() | |
SharedSync< State > | state |
std::shared_ptr< NarInfoDiskCache > | diskCache |
Stats | stats |
Friends | |
struct | ConnectionHandle |
Additional Inherited Members | |
![]() | |
using | Params = StoreReference::Params |
![]() | |
using | Settings = std::map<std::string, SettingData> |
![]() | |
using | PathsSource = std::vector<std::pair<ValidPathInfo, std::unique_ptr<Source>>> |
![]() | |
static StringSet | getDefaultSystemFeatures () |
![]() | |
static LogStore & | require (Store &store) |
![]() | |
const Setting< int > | maxConnections |
const Setting< unsigned int > | maxConnectionAge |
![]() | |
const Setting< int > | pathInfoCacheSize |
const Setting< bool > | isTrusted |
Setting< int > | priority |
Setting< bool > | wantMassQuery |
Setting< StringSet > | systemFeatures |
![]() | |
const PathSetting | storeDir_ |
const Path | storeDir = storeDir_ |
![]() | |
static constexpr const char * | MissingName = "x" |
![]() | |
static std::string | operationName = "Garbage collection" |
![]() | |
static std::string | operationName = "Build log storage and retrieval" |
|
overridevirtual |
Implements nix::LogStore.
ref< const ValidPathInfo > nix::RemoteStore::addCAToStore | ( | Source & | dump, |
std::string_view | name, | ||
ContentAddressMethod | caMethod, | ||
HashAlgorithm | hashAlgo, | ||
const StorePathSet & | references, | ||
RepairFlag | repair ) |
Add a content-addressable store path. dump
will be drained.
|
overridevirtual |
Reimplemented from nix::Store.
|
overridevirtual |
Import multiple paths into the store.
Reimplemented from nix::Store.
|
overridevirtual |
Add signatures to the specified store path. The signatures are not verified.
Reimplemented from nix::Store.
|
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.
|
overridevirtual |
Import a path into the store.
Implements nix::Store.
|
overridevirtual |
Add a content-addressable store path. dump
will be drained.
Implements nix::Store.
|
overridevirtual |
Build a single non-materialized derivation (i.e. not from an on-disk .drv file).
drvPath | This is used to deduplicate worker goals so it is imperative that is correct. That said, it doesn't literally need to be store path that would be calculated from writing this derivation to the store: it is OK if it instead is that of a Derivation which would resolve to this (by taking the outputs of it's input derivations and adding them as input sources) such that the build time referenceable-paths are the same. |
In the input-addressed case, we usually do use an "original" unresolved derivations's path, as that is what will be used in the buildPaths case. Also, the input-addressed output paths are verified only by that contents of that specific unresolved derivation, so it is nice to keep that information around so if the original derivation is ever obtained later, it can be verified whether the trusted user in fact used the proper output path.
In the content-addressed case, we want to always use the resolved drv path calculated from the provided derivation. This serves two purposes:
Reimplemented from nix::Store.
|
overridevirtual |
For each path, if it's a derivation, build it. Building a derivation means ensuring that the output paths are valid. If they are already valid, this is a no-op. Otherwise, validity can be reached in two ways. First, if the output paths is substitutable, then build the path that way. Second, the output paths can be created by running the builder, after recursively building any sub-derivations. For inputs that are not derivations, substitute them.
Reimplemented from nix::Store.
|
overridevirtual |
Like buildPaths(), but return a vector of BuildResult BuildResults corresponding to each element in paths. Note that in case of a build/substitution error, this function won't throw an exception, but return a BuildResult containing an error message.
Reimplemented from nix::Store.
|
overridevirtual |
Perform a garbage collection.
Implements nix::GcStore.
|
overridevirtual |
Establish a connection to the store, for store types that have a notion of connection. Otherwise this is a no-op.
Reimplemented from nix::Store.
|
overridevirtual |
Ensure that a path is valid. If it is not currently valid, it may be made valid by running a substitute (if defined for the path).
Reimplemented from nix::Store.
|
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.
|
overrideprotectedvirtual |
Implements nix::Store.
Reimplemented in nix::MountedSSHStore, and nix::UDSRemoteStore.
|
overridevirtual |
Get the protocol version of this store or it's connection.
Reimplemented from nix::Store.
|
overridevirtual |
Reimplemented from nix::Store.
|
overridevirtual |
std::nullopt
means we do not know.
Implements nix::Store.
|
overridevirtual |
Reimplemented from nix::Store.
Write a NAR dump of a store path.
Implements nix::Store.
Reimplemented in nix::MountedSSHStore, and nix::UDSRemoteStore.
|
overridevirtual |
Optimise the disk space usage of the Nix store by hard-linking files with the same contents.
Reimplemented from nix::Store.
|
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.
|
overridevirtual |
Query the outputs of the derivation denoted by path
.
Reimplemented from nix::Store.
|
overridevirtual |
Given a set of paths that are to be built, return the set of derivations that will be built, and the set of output paths that will be substituted.
Reimplemented from nix::Store.
|
overridevirtual |
Query the mapping outputName => outputPath for the given derivation. All outputs are mentioned so ones mising the mapping are mapped to std::nullopt
.
Reimplemented from nix::Store.
|
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.
|
overridevirtualnoexcept |
Implements nix::Store.
|
overridevirtualnoexcept |
Implements nix::Store.
|
overridevirtual |
Queries the set of incoming FS references for a store path. The result is not cleared.
Reimplemented from nix::Store.
|
overridevirtual |
Query substitute info (i.e. references, derivers and download sizes) of a map of paths to their optional ca values. The info of the first succeeding substituter for each path will be returned. If a path does not have substitute info, it's omitted from the resulting ‘infos’ map.
Reimplemented from nix::Store.
|
overridevirtual |
Query which of the given paths have substitutes.
Reimplemented from nix::Store.
|
overridevirtual |
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.
|
overridevirtual |
Query which of the given paths is valid. Optionally, try to substitute missing paths.
Reimplemented from nix::Store.
|
overridevirtual |
Add a mapping indicating that deriver!outputName
maps to the output path output
.
This is redundant for known-input-addressed and fixed-output derivations as this information is already present in the drv file, but necessary for floating-ca derivations and their dependencies as there's no way to retrieve this information otherwise.
Reimplemented from nix::Store.
|
inlineoverridevirtual |
The default instance would schedule the work on the client side, but for consistency with buildPaths
and buildDerivation
it should happen on the remote side.
We make this fail for now so we can add implement this properly later without it being a breaking change.
Reimplemented from nix::Store.
|
overrideprotectedvirtual |
Synchronises the options of the client with those of the daemon (a no-op when there’s no daemon)
Reimplemented from nix::Store.
|
overridevirtual |