Struct UnverifiedDerivation 

pub struct UnverifiedDerivation {
    builder: DerivationBuilder,
    outputs: Outputs,
}

A derivation with its output paths filled out but not verified.

This is used for working with serialized versions of the derivation without having to go through the hash derivation modulo verification required by Derivation.

UnverifiedDerivation has getters for values, is not mutable and does have output paths defined using Outputs. Those output paths are possibly loaded from somewhere else and are not guaranteed to have been verified to match the content of the derivation. When a derivation is deserialized from either ATerm format or via serde this is the returned type.

Fields

builder: DerivationBuilder

outputs: Outputs

Implementations

impl UnverifiedDerivation

pub fn verify<L>( self, name: &str, lookup_fn: L, ) -> Result<Derivation, DerivationError>

where L: HashDerivationModuloLookup,

Verify and consume this UnverifiedDerivation and return the Derivation.

It requires the name and lookup function to be passed in, as it verifies the outputs to have been calculated correctly and also calculates the drvPath.

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 from_aterm_bytes(b: &[u8]) -> Result<Self, Error<&[u8]>>

Parse an Derivation in ATerm serialization, and validate it passes our set of validations. This one does not validate output store paths to be calculated correctly.

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 into_parts(self) -> (DerivationBuilder, Outputs)

Split this UnverifiedDerivation into its constituent parts.

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 UnverifiedDerivation

fn clone(&self) -> UnverifiedDerivation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnverifiedDerivation

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

Formats the value using the given formatter.

impl DerivationAsyncExt for UnverifiedDerivation

Available on crate feature async only.

async fn from_streaming_aterm_bytes<R>( reader: R, ) -> Result<UnverifiedDerivation, Error<Vec<u8>>>

where R: AsyncBufRead + Unpin + Send,

Parse an Derivation in ATerm serialization, and validate it passes our set of validations, from a asynchronous buffered reader. This is a streaming variant of Derivation::from_aterm_bytes.

impl<'d> Deserialize<'d> for UnverifiedDerivation

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'d>,

Deserialize this value from the given Serde deserializer.

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 UnverifiedDerivation

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 Serialize for UnverifiedDerivation

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 TryFrom<BasicDerivation> for UnverifiedDerivation

Available on crate feature daemon only.

type Error = DerivationError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for UnverifiedDerivation

impl StructuralPartialEq for UnverifiedDerivation