Enum holochain::core::workflow::app_validation_workflow::Outcome

pub enum Outcome {
    Accepted,
    AwaitingDeps(Vec<AnyDhtHash>),
    Rejected(String),
}

The outcome of sys validation

Variants

Accepted

Moves to integration

AwaitingDeps(Vec<AnyDhtHash>)

Stays in limbo because a dependency needs is required to validate and could not be found

Rejected(String)

Moves to integration with status rejected

Implementations

impl Outcome

pub fn awaiting<E, I: Into<AnyDhtHash> + Clone>(
    h: &I
) -> OutcomeOrError<Self, E>

Helper function for creating awaiting deps and exiting when the dependency isn’t found

Examples found in repository

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

async fn dhtop_to_op(op: DhtOp, cascade: &mut Cascade) -> AppValidationOutcome<Op> {
    let op = match op {
        DhtOp::StoreRecord(signature, action, entry) => Op::StoreRecord(StoreRecord {
            record: Record::new(
                SignedActionHashed::with_presigned(
                    ActionHashed::from_content_sync(action),
                    signature,
                ),
                entry.map(|e| *e),
            ),
        }),
        DhtOp::StoreEntry(signature, action, entry) => Op::StoreEntry(StoreEntry {
            action: SignedHashed::new(action.into(), signature),
            entry: *entry,
        }),
        DhtOp::RegisterAgentActivity(signature, action) => {
            Op::RegisterAgentActivity(RegisterAgentActivity {
                action: SignedActionHashed::with_presigned(
                    ActionHashed::from_content_sync(action),
                    signature,
                ),
                cached_entry: None,
            })
        }
        DhtOp::RegisterUpdatedContent(signature, update, entry)
        | DhtOp::RegisterUpdatedRecord(signature, update, entry) => {
            let new_entry = match update.entry_type.visibility() {
                EntryVisibility::Public => match entry {
                    Some(entry) => Some(*entry),
                    None => Some(
                        cascade
                            .retrieve_entry(update.entry_hash.clone(), Default::default())
                            .await?
                            .map(|e| e.into_content())
                            .ok_or_else(|| Outcome::awaiting(&update.entry_hash))?,
                    ),
                },
                _ => None,
            };
            let original_entry = if let EntryVisibility::Public = update.entry_type.visibility() {
                Some(
                    cascade
                        .retrieve_entry(update.original_entry_address.clone(), Default::default())
                        .await?
                        .map(|e| e.into_content())
                        .ok_or_else(|| Outcome::awaiting(&update.original_entry_address))?,
                )
            } else {
                None
            };

            let original_action = cascade
                .retrieve_action(update.original_action_address.clone(), Default::default())
                .await?
                .and_then(|sh| {
                    NewEntryAction::try_from(sh.hashed.content)
                        .ok()
                        .map(|h| h.into())
                })
                .ok_or_else(|| Outcome::awaiting(&update.original_action_address))?;
            Op::RegisterUpdate(RegisterUpdate {
                update: SignedHashed::new(update, signature),
                new_entry,
                original_action,
                original_entry,
            })
        }
        DhtOp::RegisterDeletedBy(signature, delete)
        | DhtOp::RegisterDeletedEntryAction(signature, delete) => {
            let original_action: EntryCreationAction = cascade
                .retrieve_action(delete.deletes_address.clone(), Default::default())
                .await?
                .and_then(|sh| {
                    NewEntryAction::try_from(sh.hashed.content)
                        .ok()
                        .map(|h| h.into())
                })
                .ok_or_else(|| Outcome::awaiting(&delete.deletes_address))?;

            let original_entry = if let EntryVisibility::Public =
                original_action.entry_type().visibility()
            {
                Some(
                    cascade
                        .retrieve_entry(delete.deletes_entry_address.clone(), Default::default())
                        .await?
                        .map(|e| e.into_content())
                        .ok_or_else(|| Outcome::awaiting(&delete.deletes_entry_address))?,
                )
            } else {
                None
            };
            Op::RegisterDelete(RegisterDelete {
                delete: SignedHashed::new(delete, signature),
                original_action,
                original_entry,
            })
        }
        DhtOp::RegisterAddLink(signature, create_link) => {
            Op::RegisterCreateLink(RegisterCreateLink {
                create_link: SignedHashed::new(create_link, signature),
            })
        }
        DhtOp::RegisterRemoveLink(signature, delete_link) => {
            let create_link = cascade
                .retrieve_action(delete_link.link_add_address.clone(), Default::default())
                .await?
                .and_then(|sh| CreateLink::try_from(sh.hashed.content).ok())
                .ok_or_else(|| Outcome::awaiting(&delete_link.link_add_address))?;
            Op::RegisterDeleteLink(RegisterDeleteLink {
                delete_link: SignedHashed::new(delete_link, signature),
                create_link,
            })
        }
    };
    Ok(op)
}

pub fn rejected<E, I: Into<String>>(s: I) -> OutcomeOrError<Self, E>

Helper function for creating rejected outcomes

Examples found in repository

src/core/workflow/app_validation_workflow.rs (lines 526-529)

pub fn entry_creation_zomes_to_invoke(
    action: &EntryCreationAction,
    ribosome: &impl RibosomeT,
) -> AppValidationOutcome<ZomesToInvoke> {
    match action {
        EntryCreationAction::Create(Create {
            entry_type: EntryType::App(app_entry_def),
            ..
        })
        | EntryCreationAction::Update(Update {
            entry_type: EntryType::App(app_entry_def),
            ..
        }) => {
            let zome = ribosome
                .get_integrity_zome(&app_entry_def.zome_index())
                .ok_or_else(|| {
                    Outcome::rejected(&format!(
                        "Zome does not exist for {:?}",
                        app_entry_def.zome_index()
                    ))
                })?;
            Ok(ZomesToInvoke::OneIntegrity(zome))
        }
        _ => Ok(ZomesToInvoke::AllIntegrity),
    }
}

fn create_link_zomes_to_invoke(
    create_link: &CreateLink,
    ribosome: &impl RibosomeT,
) -> AppValidationOutcome<ZomesToInvoke> {
    let zome = ribosome
        .get_integrity_zome(&create_link.zome_index)
        .ok_or_else(|| {
            Outcome::rejected(&format!(
                "Zome does not exist for {:?}",
                create_link.link_type
            ))
        })?;
    Ok(ZomesToInvoke::One(zome.erase_type()))
}

/// Get the zomes to invoke for an [`Op::StoreRecord`].
fn store_record_zomes_to_invoke(
    action: &Action,
    ribosome: &impl RibosomeT,
) -> AppValidationOutcome<ZomesToInvoke> {
    match action {
        Action::CreateLink(create_link) => create_link_zomes_to_invoke(create_link, ribosome),
        Action::Create(Create {
            entry_type: EntryType::App(AppEntryDef { zome_index, .. }),
            ..
        })
        | Action::Update(Update {
            entry_type: EntryType::App(AppEntryDef { zome_index, .. }),
            ..
        }) => {
            let zome = ribosome.get_integrity_zome(zome_index).ok_or_else(|| {
                Outcome::rejected(&format!("Zome does not exist for {:?}", zome_index))
            })?;
            Ok(ZomesToInvoke::OneIntegrity(zome))
        }
        _ => Ok(ZomesToInvoke::AllIntegrity),
    }
}

pub fn exit_with_awaiting<T, I: Into<AnyDhtHash>, It: IntoIterator<Item = I>>(
    h: It
) -> Result<T, OutcomeOrError<Outcome, AppValidationError>>

Exit early with an awaiting outcome

pub fn accepted<T>() -> Result<T, OutcomeOrError<Outcome, AppValidationError>>

Early exits with an accepted outcome

pub fn exit_with_rejected<T, I: Into<String>>(
    reason: I
) -> Result<T, OutcomeOrError<Outcome, AppValidationError>>

Exit early with a rejected outcome

Trait Implementations

impl Debug for Outcome

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

Formats the value using the given formatter.