Struct DaemonStore

pub struct DaemonStore<C: AsyncReadExt + AsyncWriteExt + Unpin> {
    pub proto: Proto,
    /* private fields */
}

Store backed by a nix-daemon (or compatible store). Implements crate::Store.

use nix_daemon::{Store, Progress, nix::DaemonStore};

let mut store = DaemonStore::builder()
    .connect_unix("/nix/var/nix/daemon-socket/socket")
    .await?;

let is_valid_path = store.is_valid_path("/nix/store/...").result().await?;

Fields

proto: Proto

Negotiated protocol version.

Implementations

impl DaemonStore<UnixStream>

pub fn builder() -> DaemonStoreBuilder

Returns a Builder.

Trait Implementations

impl<C: Debug + AsyncReadExt + AsyncWriteExt + Unpin> Debug for DaemonStore<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: AsyncReadExt + AsyncWriteExt + Unpin + Send> Store for DaemonStore<C>

type Error = Error

fn is_valid_path<S: AsRef<str> + Send + Sync + Debug>( &mut self, path: S, ) -> impl Progress<T = bool, Error = Self::Error>

Returns whether a store path is valid.

fn has_substitutes<P: AsRef<str> + Send + Sync + Debug>( &mut self, path: P, ) -> impl Progress<T = bool, Error = Self::Error>

Returns whether Self::query_substitutable_paths() would return anything.

fn add_to_store<SN: AsRef<str> + Send + Sync + Debug, SC: AsRef<str> + Send + Sync + Debug, Refs, R>( &mut self, name: SN, cam_str: SC, refs: Refs, repair: bool, source: R, ) -> impl Progress<T = (String, PathInfo), Error = Self::Error>

where Refs: IntoIterator + Send + Debug, Refs::IntoIter: ExactSizeIterator + Send, Refs::Item: AsRef<str> + Send + Sync, R: AsyncReadExt + Unpin + Send + Debug,

Adds a file to the store.

fn build_paths<Paths>( &mut self, paths: Paths, mode: BuildMode, ) -> impl Progress<T = (), Error = Self::Error>

where Paths: IntoIterator + Send + Debug, Paths::IntoIter: ExactSizeIterator + Send, Paths::Item: AsRef<str> + Send + Sync,

Builds the specified paths.

fn ensure_path<Path: AsRef<str> + Send + Sync + Debug>( &mut self, path: Path, ) -> impl Progress<T = (), Error = Self::Error>

Ensure the specified store path exists.

fn add_temp_root<Path: AsRef<str> + Send + Sync + Debug>( &mut self, path: Path, ) -> impl Progress<T = (), Error = Self::Error>

Creates a temporary GC root, which persists until the client disconnects.

fn add_indirect_root<Path: AsRef<str> + Send + Sync + Debug>( &mut self, path: Path, ) -> impl Progress<T = (), Error = Self::Error>

Creates a persistent GC root. This is what’s normally meant by a GC root.

fn find_roots( &mut self, ) -> impl Progress<T = HashMap<String, String>, Error = Self::Error>

Returns the (link, target) of all known GC roots.

fn set_options( &mut self, opts: ClientSettings, ) -> impl Progress<T = (), Error = Self::Error>

Applies client options. This changes the behaviour of future commands.

fn query_pathinfo<S: AsRef<str> + Send + Sync + Debug>( &mut self, path: S, ) -> impl Progress<T = Option<PathInfo>, Error = Self::Error>

Returns a PathInfo struct for the given path.

fn query_valid_paths<Paths>( &mut self, paths: Paths, use_substituters: bool, ) -> impl Progress<T = Vec<String>, Error = Self::Error>

where Paths: IntoIterator + Send + Debug, Paths::IntoIter: ExactSizeIterator + Send, Paths::Item: AsRef<str> + Send + Sync,

Returns which of the passed paths are valid.

fn query_substitutable_paths<Paths>( &mut self, paths: Paths, ) -> impl Progress<T = Vec<String>, Error = Self::Error>

where Paths: IntoIterator + Send + Debug, Paths::IntoIter: ExactSizeIterator + Send, Paths::Item: AsRef<str> + Send + Sync,

Returns paths which can be substituted.

fn query_valid_derivers<S: AsRef<str> + Send + Sync + Debug>( &mut self, path: S, ) -> impl Progress<T = Vec<String>, Error = Self::Error>

Returns a list of valid derivers for a path. This is sort of like PathInfo::deriver, but it doesn’t lie to you.

fn query_missing<Ps>( &mut self, paths: Ps, ) -> impl Progress<T = Missing, Error = Self::Error>

where Ps: IntoIterator + Send + Debug, Ps::IntoIter: ExactSizeIterator + Send, Ps::Item: AsRef<str> + Send + Sync,

Takes a list of paths and queries which would be built, substituted or unknown, along with an estimate of the cumulative download and NAR sizes.

fn query_derivation_output_map<P: AsRef<str> + Send + Sync + Debug>( &mut self, path: P, ) -> impl Progress<T = HashMap<String, String>, Error = Self::Error>

Returns a map of (output, store path) for the given derivation.

fn build_paths_with_results<Ps>( &mut self, paths: Ps, mode: BuildMode, ) -> impl Progress<T = HashMap<String, BuildResult>, Error = Self::Error>

where Ps: IntoIterator + Send + Debug, Ps::IntoIter: ExactSizeIterator + Send, Ps::Item: AsRef<str> + Send + Sync,

Like Self::build_paths(), but returns a BuildResult for each entry in paths.