Struct PathInfo

pub struct PathInfo {
    pub store_path: StorePath<String>,
    pub node: Node,
    pub references: Vec<StorePath<String>>,
    pub nar_size: u64,
    pub nar_sha256: [u8; 32],
    pub signatures: Vec<Signature<String>>,
    pub deriver: Option<StorePath<String>>,
    pub ca: Option<CAHash>,
}

Holds metadata about a store path, but not its contents.

This is somewhat equivalent to the information Nix holds in its SQLite database, or publishes as .narinfo files, except we also embed the snix_castore::Node describing the contents in the castore model.

Fields

store_path: StorePath<String>

The store path this is about.

node: Node

The contents in the snix-castore model.

references: Vec<StorePath<String>>

A list of references.

nar_size: u64

The size of the NAR representation of the contents, in bytes.

nar_sha256: [u8; 32]

The sha256 digest of the NAR representation of the contents.

signatures: Vec<Signature<String>>

The signatures, usually shown in a .narinfo file.

deriver: Option<StorePath<String>>

The StorePath of the .drv file producing this output. The .drv suffix is omitted in its name field.

ca: Option<CAHash>

The CA field in the .narinfo. Its textual representations seen in the wild are one of the following:

• fixed:r:sha256:1gcky5hlf5vqfzpyhihydmm54grhc94mcs8w7xr8613qsqb1v2j6 fixed-output derivations using “recursive” outputHashMode.
• fixed:sha256:19xqkh72crbcba7flwxyi3n293vav6d7qkzkh2v4zfyi4iia8vj8 fixed-output derivations using "flat" outputHashMode`
• text:sha256:19xqkh72crbcba7flwxyi3n293vav6d7qkzkh2v4zfyi4iia8vj8 Text hashing, used for uploaded .drv files and outputs produced by builtins.toFile.

Semantically, they can be split into the following components:

• “content address prefix”. Currently, “fixed” and “text” are supported.
• “hash mode”. Currently, “flat” and “recursive” are supported.
• “hash type”. The underlying hash function used. Currently, sha1, md5, sha256, sha512.
• “digest”. The digest itself.

There are some restrictions on the possible combinations. For example, text and fixed:recursive always imply sha256.

Implementations

impl PathInfo

pub fn to_narinfo(&self) -> NarInfo<'_>

Reconstructs a [nix_compat::narinfo::NarInfo<’_>].

It does very little allocation (a Vec each for signatures and references), the rest points to data owned elsewhere.

It can be used to validate Signatures, or render a .narinfo file (after some more fields are populated)

Keep in mind this is not able to reconstruct all data present in the NarInfo<’_>, as some of it is not stored at all:

• the system, file_hash and file_size fields are set to None.
• the URL is set to an empty string.
• Compression is set to “none”

If you want to render it out to a string and be able to parse it back in, at least URL must be set again.

Trait Implementations

impl Clone for PathInfo

fn clone(&self) -> PathInfo

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PathInfo

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

Formats the value using the given formatter.

impl From<PathInfo> for PathInfo

fn from(value: PathInfo) -> Self

Converts to this type from the input type.

impl PartialEq for PathInfo

fn eq(&self, other: &PathInfo) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<PathInfo> for PathInfo

type Error = ValidatePathInfoError

The type returned in the event of a conversion error.

fn try_from(value: PathInfo) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for PathInfo

impl StructuralPartialEq for PathInfo