Struct holochain::core::ribosome::guest_callback::validate::ValidateInvocation

pub struct ValidateInvocation { /* private fields */ }

An invocation of the validate callback function.

Implementations

impl ValidateInvocation

pub fn new(
    zomes_to_invoke: ZomesToInvoke,
    data: &Op
) -> Result<Self, SerializedBytesError>

Examples found in repository

src/core/workflow/app_validation_workflow.rs (line 495)

pub async fn validate_op<R>(
    op: &Op,
    workspace: HostFnWorkspaceRead,
    network: &HolochainP2pDna,
    ribosome: &R,
) -> AppValidationOutcome<Outcome>
where
    R: RibosomeT,
{
    let zomes_to_invoke = match op {
        Op::RegisterAgentActivity(RegisterAgentActivity { .. }) => ZomesToInvoke::AllIntegrity,
        Op::StoreRecord(StoreRecord { record }) => {
            store_record_zomes_to_invoke(record.action(), ribosome)?
        }
        Op::StoreEntry(StoreEntry {
            action:
                SignedHashed {
                    hashed:
                        HoloHashed {
                            content: action, ..
                        },
                    ..
                },
            ..
        }) => entry_creation_zomes_to_invoke(action, ribosome)?,
        Op::RegisterUpdate(RegisterUpdate {
            original_action, ..
        })
        | Op::RegisterDelete(RegisterDelete {
            original_action, ..
        }) => entry_creation_zomes_to_invoke(original_action, ribosome)?,
        Op::RegisterCreateLink(RegisterCreateLink {
            create_link:
                SignedHashed {
                    hashed:
                        HoloHashed {
                            content: action, ..
                        },
                    ..
                },
            ..
        }) => create_link_zomes_to_invoke(action, ribosome)?,
        Op::RegisterDeleteLink(RegisterDeleteLink {
            create_link: action,
            ..
        }) => create_link_zomes_to_invoke(action, ribosome)?,
    };

    let invocation = ValidateInvocation::new(zomes_to_invoke, op)
        .map_err(|e| AppValidationError::RibosomeError(e.into()))?;
    let outcome = run_validation_callback_inner(
        invocation,
        ribosome,
        workspace,
        network.clone(),
        (HashSet::<AnyDhtHash>::new(), 0),
        HashSet::new(),
    )
    .await?;

    Ok(outcome)
}

Trait Implementations

impl Clone for ValidateInvocation

fn clone(&self) -> ValidateInvocation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ValidateInvocation

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

Formats the value using the given formatter.

impl Invocation for ValidateInvocation

fn zomes(&self) -> ZomesToInvoke

Some invocations call into a single zome and some call into many or all zomes. An example of an invocation that calls across all zomes is init. Init must pass for every zome in order for the Dna overall to successfully init. An example of an invocation that calls a single zome is validation of an entry, because the entry is only defined in a single zome, so it only makes sense for that exact zome to define the validation logic for that entry. In the future this may be expanded to support a subset of zomes that is larger than one. For example, we may want to trigger a callback in all zomes that implement a trait/interface, but this doesn’t exist yet, so the only valid options are All or One.

fn fn_components(&self) -> FnComponents

Invocations execute in a “sparse” manner of decreasing specificity. In technical terms this means that the list of strings in FnComponents will be concatenated into a single function name to be called, then the last string will be removed and a shorter function name will be attempted and so on until all variations have been attempted. For example, if FnComponents was vec![“foo”, “bar”, “baz”] it would loop as “foo_bar_baz” then “foo_bar” then “foo”. All of those three callbacks that are defined will be called unless a definitive callback result is returned. See CallbackResult::is_definitive in zome_types. All of the individual callback results are then folded into a single overall result value as a From implementation on the invocation results structs (e.g. zome results vs. ribosome results).

fn host_input(self) -> Result<ExternIO, SerializedBytesError>

the serialized input from the host for the wasm call this is intentionally NOT a reference to self because ExternIO may be huge we want to be careful about cloning invocations

fn auth(&self) -> InvocationAuth