Struct Derivation 

pub struct Derivation {
    drv_path: StorePath,
    inner: UnverifiedDerivation,
}

A verified derivation with its StorePath.

A Derivation can only be created by also verifying that all its data is valid and that its output paths and StorePath matches that data and the hash derivation modulo of its dependencies.

Fields

drv_path: StorePath

inner: UnverifiedDerivation

Implementations

impl Derivation

pub fn from_aterm_bytes<'i, L>( name: &str, lookup_fn: L, b: &'i [u8], ) -> Result<Derivation, Error<&'i [u8]>>

where L: HashDerivationModuloLookup,

Parse a Derivation in ATerm serialization, and verify that it is valid and that its output paths have been calculated correctly.

Use UnverifiedDerivation::from_aterm_bytes to parse without verifying this.

pub fn into_parts(self) -> (StorePath, DerivationBuilder, Outputs)

Split this Derivation into its constituent parts.

pub fn as_unverified(&self) -> &UnverifiedDerivation

Return this Derivation as a UnverifiedDerivation.

pub fn into_unverified(self) -> UnverifiedDerivation

Convert this Derivation into a UnverifiedDerivation.

pub fn name(&self) -> &str

Return name of this derivation.

This is the name of the store path with the suffix .drv stripped.

pub fn drv_path(&self) -> &StorePath

Return StorePath of this derivation.

pub fn recalculate_derivation_path(&self) -> Result<StorePath, DerivationError>

Recalculate and return the derivation StorePath.

pub fn recalculate_outputs<L>( &self, lookup: L, ) -> Result<Outputs, DerivationError>

where L: HashDerivationModuloLookup,

Recalculate and return the Outputs of this Derivation.

Methods from Deref<Target = UnverifiedDerivation>

pub fn serialize(&self, writer: &mut impl Write) -> Result<(), Error>

write the Derivation to the given std::io::Write, in ATerm format.

The only errors returned are from the passed in writer.

pub fn to_aterm_bytes(&self) -> Vec<u8>

return the ATerm serialization.

pub fn calculate_derivation_path( &self, name: &str, ) -> Result<StorePath, DerivationError>

Calculate and return the drv path of this UnverifiedDerivation.

The drv path is calculated by invoking store_path::build_text_path, using the provided name with a .drv suffix added. All input_sources and keys of input_derivations are used as references. And the ATerm string of the UnverifiedDerivation is used as content.

pub fn fod_digest(&self) -> Option<Sha256>

Returns the FOD digest, if the derivation is fixed-output, or None if it’s not.

pub fn hash_derivation_modulo<L>( &self, lookup: L, ) -> Result<Sha256, DerivationError>

where L: HashDerivationModuloLookup,

Calculates the hash derivation module of this UnverifiedDerivation.

pub fn recalculate_outputs<L>( &self, name: &str, lookup: L, ) -> Result<Outputs, DerivationError>

where L: HashDerivationModuloLookup,

Recalculate and return the Outputs of this UnverifiedDerivation.

pub fn arguments(&self) -> &[String]

Return command line arguments to builder

pub fn command(&self) -> &str

Return builder to execute.

This is usually a path to bash.

NOTE: This is called builder in cppnix and in Nix code.

pub fn environment(&self) -> &BTreeMap<String, BString>

Return environment variables to include in build environmennt.

pub fn input_derivations(&self) -> &BTreeMap<StorePath, BTreeSet<OutputName>>

Map from drv path to output names used from this derivation.

pub fn input_sources(&self) -> &BTreeSet<StorePath>

Return plain store paths of additional inputs.

pub fn outputs(&self) -> &Outputs

Return the outputs of this UnverifiedDerivation.

pub fn system(&self) -> &str

Return system used to build this derivation.

Trait Implementations

impl AsRef<UnverifiedDerivation> for Derivation

fn as_ref(&self) -> &UnverifiedDerivation

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Derivation

fn clone(&self) -> Derivation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Derivation

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

Formats the value using the given formatter.

impl Deref for Derivation

type Target = UnverifiedDerivation

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<Derivation> for UnverifiedDerivation

fn from(value: Derivation) -> Self

Converts to this type from the input type.

impl PartialEq<&Derivation> for UnverifiedDerivation

fn eq(&self, other: &&Derivation) -> 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 PartialEq<&UnverifiedDerivation> for Derivation

fn eq(&self, other: &&UnverifiedDerivation) -> 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 PartialEq<Derivation> for UnverifiedDerivation

fn eq(&self, other: &Derivation) -> 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 PartialEq<UnverifiedDerivation> for Derivation

fn eq(&self, other: &UnverifiedDerivation) -> 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 PartialEq for Derivation

fn eq(&self, other: &Derivation) -> 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 Serialize for Derivation

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Derivation

impl StructuralPartialEq for Derivation